Rename from "(un)lock" to "(un)map" for geometry buffers.

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 38 matching lines @@
         if (NULL != buffer) {
             *fPreallocBuffers.append() = buffer;
         }
     }
 }
 
 GrBufferAllocPool::~GrBufferAllocPool() {
     VALIDATE();
     if (fBlocks.count()) {
         GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
-        if (buffer->isLocked()) {
-            buffer->unlock();
+        if (buffer->isMapped()) {
+            buffer->unmap();
         }
     }
     while (!fBlocks.empty()) {
         destroyBlock();
     }
     fPreallocBuffers.unrefAll();
     releaseGpuRef();
 }
 
 void GrBufferAllocPool::releaseGpuRef() {
     if (fGpuIsReffed) {
         fGpu->unref();
         fGpuIsReffed = false;
     }
 }
 
 void GrBufferAllocPool::reset() {
     VALIDATE();
     fBytesInUse = 0;
     if (fBlocks.count()) {
         GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
-        if (buffer->isLocked()) {
-            buffer->unlock();
+        if (buffer->isMapped()) {
+            buffer->unmap();
         }
     }
     // fPreallocBuffersInUse will be decremented down to zero in the while loop
     int preallocBuffersInUse = fPreallocBuffersInUse;
     while (!fBlocks.empty()) {
         this->destroyBlock();
     }
     if (fPreallocBuffers.count()) {
         // must set this after above loop.
         fPreallocBufferStartIdx = (fPreallocBufferStartIdx +
                                    preallocBuffersInUse) %
                                   fPreallocBuffers.count();
     }
     // we may have created a large cpu mirror of a large VB. Reset the size
     // to match our pre-allocated VBs.
     fCpuData.reset(fMinBlockSize);
     SkASSERT(0 == fPreallocBuffersInUse);
     VALIDATE();
 }
 
-void GrBufferAllocPool::unlock() {
+void GrBufferAllocPool::unmap() {
     VALIDATE();
 
     if (NULL != fBufferPtr) {
         BufferBlock& block = fBlocks.back();
-        if (block.fBuffer->isLocked()) {
-            block.fBuffer->unlock();
+        if (block.fBuffer->isMapped()) {
+            block.fBuffer->unmap();
         } else {
             size_t flushSize = block.fBuffer->gpuMemorySize() - block.fBytesFree;
-            flushCpuData(fBlocks.back().fBuffer, flushSize);
+            this->flushCpuData(fBlocks.back().fBuffer, flushSize);
         }
         fBufferPtr = NULL;
     }
     VALIDATE();
 }
 
 #ifdef SK_DEBUG
 void GrBufferAllocPool::validate(bool unusedBlockAllowed) const {
     if (NULL != fBufferPtr) {
         SkASSERT(!fBlocks.empty());
-        if (fBlocks.back().fBuffer->isLocked()) {
+        if (fBlocks.back().fBuffer->isMapped()) {
             GrGeometryBuffer* buf = fBlocks.back().fBuffer;
-            SkASSERT(buf->lockPtr() == fBufferPtr);
+            SkASSERT(buf->mapPtr() == fBufferPtr);
         } else {
             SkASSERT(fCpuData.get() == fBufferPtr);
         }
     } else {
-        SkASSERT(fBlocks.empty() || !fBlocks.back().fBuffer->isLocked());
+        SkASSERT(fBlocks.empty() || !fBlocks.back().fBuffer->isMapped());
     }
     size_t bytesInUse = 0;
     for (int i = 0; i < fBlocks.count() - 1; ++i) {
-        SkASSERT(!fBlocks[i].fBuffer->isLocked());
+        SkASSERT(!fBlocks[i].fBuffer->isMapped());
     }
     for (int i = 0; i < fBlocks.count(); ++i) {
         size_t bytes = fBlocks[i].fBuffer->gpuMemorySize() - fBlocks[i].fBytesFree;
         bytesInUse += bytes;
         SkASSERT(bytes || unusedBlockAllowed);
     }
 
     SkASSERT(bytesInUse == fBytesInUse);
     if (unusedBlockAllowed) {
         SkASSERT((fBytesInUse && !fBlocks.empty()) ||
@@ skipping 83 matching lines @@
 
     while (bytes) {
         // caller shouldnt try to put back more than they've taken
         SkASSERT(!fBlocks.empty());
         BufferBlock& block = fBlocks.back();
         size_t bytesUsed = block.fBuffer->gpuMemorySize() - block.fBytesFree;
         if (bytes >= bytesUsed) {
             bytes -= bytesUsed;
             fBytesInUse -= bytesUsed;
             // if we locked a vb to satisfy the make space and we're releasing
-            // beyond it, then unlock it.
-            if (block.fBuffer->isLocked()) {
-                block.fBuffer->unlock();
+            // beyond it, then unmap it.
+            if (block.fBuffer->isMapped()) {
+                block.fBuffer->unmap();
             }
             this->destroyBlock();
         } else {
             block.fBytesFree += bytes;
             fBytesInUse -= bytes;
             bytes = 0;
             break;
         }
     }
     if (!fPreallocBuffersInUse && fPreallocBuffers.count()) {
@@ skipping 27 matching lines @@
         if (NULL == block.fBuffer) {
             fBlocks.pop_back();
             return false;
         }
     }
 
     block.fBytesFree = size;
     if (NULL != fBufferPtr) {
         SkASSERT(fBlocks.count() > 1);
         BufferBlock& prev = fBlocks.fromBack(1);
-        if (prev.fBuffer->isLocked()) {
-            prev.fBuffer->unlock();
+        if (prev.fBuffer->isMapped()) {
+            prev.fBuffer->unmap();
         } else {
             flushCpuData(prev.fBuffer,
                          prev.fBuffer->gpuMemorySize() - prev.fBytesFree);
         }
         fBufferPtr = NULL;
     }
 
     SkASSERT(NULL == fBufferPtr);
 
-    // If the buffer is CPU-backed we lock it because it is free to do so and saves a copy.
-    // Otherwise when buffer locking is supported:
-    //      a) If the frequently reset hint is set we only lock when the requested size meets a
+    // 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 lock if the buffer size is greater than the threshold.
-    bool attemptLock = block.fBuffer->isCPUBacked();
-    if (!attemptLock && GrDrawTargetCaps::kNone_MapFlags != fGpu->caps()->mapBufferFlags()) {
+    //      b) If the hint is not set 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) {
-            attemptLock = requestSize > GR_GEOM_BUFFER_LOCK_THRESHOLD;
+            attemptMap = requestSize > GR_GEOM_BUFFER_MAP_THRESHOLD;
         } else {
-            attemptLock = size > GR_GEOM_BUFFER_LOCK_THRESHOLD;
+            attemptMap = size > GR_GEOM_BUFFER_MAP_THRESHOLD;
         }
     }
 
-    if (attemptLock) {
-        fBufferPtr = block.fBuffer->lock();
+    if (attemptMap) {
+        fBufferPtr = block.fBuffer->map();
     }
 
     if (NULL == fBufferPtr) {
         fBufferPtr = fCpuData.reset(size);
     }
 
     VALIDATE(true);
 
     return true;
 }
 
 void GrBufferAllocPool::destroyBlock() {
     SkASSERT(!fBlocks.empty());
 
     BufferBlock& block = fBlocks.back();
     if (fPreallocBuffersInUse > 0) {
         uint32_t prevPreallocBuffer = (fPreallocBuffersInUse +
                                        fPreallocBufferStartIdx +
                                        (fPreallocBuffers.count() - 1)) %
                                       fPreallocBuffers.count();
         if (block.fBuffer == fPreallocBuffers[prevPreallocBuffer]) {
             --fPreallocBuffersInUse;
         }
     }
-    SkASSERT(!block.fBuffer->isLocked());
+    SkASSERT(!block.fBuffer->isMapped());
     block.fBuffer->unref();
     fBlocks.pop_back();
     fBufferPtr = NULL;
 }
 
 void GrBufferAllocPool::flushCpuData(GrGeometryBuffer* buffer,
                                      size_t flushSize) {
     SkASSERT(NULL != buffer);
-    SkASSERT(!buffer->isLocked());
+    SkASSERT(!buffer->isMapped());
     SkASSERT(fCpuData.get() == fBufferPtr);
     SkASSERT(flushSize <= buffer->gpuMemorySize());
     VALIDATE(true);
 
     if (GrDrawTargetCaps::kNone_MapFlags != fGpu->caps()->mapBufferFlags() &&
-        flushSize > GR_GEOM_BUFFER_LOCK_THRESHOLD) {
-        void* data = buffer->lock();
+        flushSize > GR_GEOM_BUFFER_MAP_THRESHOLD) {
+        void* data = buffer->map();
         if (NULL != data) {
             memcpy(data, fBufferPtr, flushSize);
-            buffer->unlock();
+            buffer->unmap();
             return;
         }
     }
     buffer->updateData(fBufferPtr, flushSize);
     VALIDATE(true);
 }
 
 GrGeometryBuffer* GrBufferAllocPool::createBuffer(size_t size) {
     if (kIndex_BufferType == fBufferType) {
         return fGpu->createIndexBuffer(size, true);
@@ skipping 109 matching lines @@
     }
 }
 
 int GrIndexBufferAllocPool::preallocatedBufferIndices() const {
     return static_cast<int>(INHERITED::preallocatedBufferSize() / sizeof(uint16_t));
 }
 
 int GrIndexBufferAllocPool::currentBufferIndices() const {
     return currentBufferItems(sizeof(uint16_t));
 }