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

src/gpu/GrBufferAllocPool.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrBufferAllocPool_DEFINED
 #define GrBufferAllocPool_DEFINED
 
 #include "SkTArray.h"
 #include "SkTDArray.h"
 #include "SkTypes.h"
 
 class GrGeometryBuffer;
 class GrGpu;
 
 /**
  * A pool of geometry buffers tied to a GrGpu.
  *
  * The pool allows a client to make space for geometry and then put back excess
  * space if it over allocated. When a client is ready to draw from the pool
- * it calls unlock on the pool ensure buffers are ready for drawing. The pool
+ * it calls unmap on the pool ensure buffers are ready for drawing. The pool
  * can be reset after drawing is completed to recycle space.
  *
  * At creation time a minimum per-buffer size can be specified. Additionally,
  * a number of buffers to preallocate can be specified. These will
  * be allocated at the min size and kept around until the pool is destroyed.
  */
 class GrBufferAllocPool : SkNoncopyable {
 public:
     /**
-     * Ensures all buffers are unlocked and have all data written to them.
+     * Ensures all buffers are unmapped and have all data written to them.
      * Call before drawing using buffers from the pool.
      */
-    void unlock();
+    void unmap();
 
     /**
      *  Invalidates all the data in the pool, unrefs non-preallocated buffers.
      */
     void reset();
 
     /**
      * Gets the number of preallocated buffers that are yet to be used.
      */
     int preallocatedBuffersRemaining() const;
@@ skipping 23 matching lines @@
         kVertex_BufferType,
         kIndex_BufferType,
     };
 
     /**
      * Constructor
      *
      * @param gpu                   The GrGpu used to create the buffers.
      * @param bufferType            The type of buffers to create.
      * @param frequentResetHint     A hint that indicates that the pool
-     *                              should expect frequent unlock() calls
+     *                              should expect frequent unmap() calls
      *                              (as opposed to many makeSpace / acquires
      *                              between resets).
      * @param bufferSize            The minimum size of created buffers.
      *                              This value will be clamped to some
      *                              reasonable minimum.
      * @param preallocBufferCnt     The pool will allocate this number of
      *                              buffers at bufferSize and keep them until it
      *                              is destroyed.
      */
      GrBufferAllocPool(GrGpu* gpu,
@@ skipping 11 matching lines @@
      */
     size_t preallocatedBufferSize() const {
         return fPreallocBuffers.count() ? fMinBlockSize : 0;
     }
 
     /**
      * Returns a block of memory to hold data. A buffer designated to hold the
      * data is given to the caller. The buffer may or may not be locked. The
      * returned ptr remains valid until any of the following:
      *      *makeSpace is called again.
-     *      *unlock is called.
+     *      *unmap is called.
      *      *reset is called.
      *      *this object is destroyed.
      *
-     * Once unlock on the pool is called the data is guaranteed to be in the
+     * Once unmap on the pool is called the data is guaranteed to be in the
      * buffer at the offset indicated by offset. Until that time it may be
      * in temporary storage and/or the buffer may be locked.
      *
      * @param size         the amount of data to make space for
      * @param alignment    alignment constraint from start of buffer
      * @param buffer       returns the buffer that will hold the data.
      * @param offset       returns the offset into buffer of the data.
      * @return pointer to where the client should write the data.
      */
     void* makeSpace(size_t size,
@@ skipping 56 matching lines @@
 /**
  * A GrBufferAllocPool of vertex buffers
  */
 class GrVertexBufferAllocPool : public GrBufferAllocPool {
 public:
     /**
      * Constructor
      *
      * @param gpu                   The GrGpu used to create the vertex buffers.
      * @param frequentResetHint     A hint that indicates that the pool
-     *                              should expect frequent unlock() calls
+     *                              should expect frequent unmap() calls
      *                              (as opposed to many makeSpace / acquires
      *                              between resets).
      * @param bufferSize            The minimum size of created VBs This value
      *                              will be clamped to some reasonable minimum.
      * @param preallocBufferCnt     The pool will allocate this number of VBs at
      *                              bufferSize and keep them until it is
      *                              destroyed.
      */
     GrVertexBufferAllocPool(GrGpu* gpu,
                             bool frequentResetHint,
                             size_t bufferSize = 0,
                             int preallocBufferCnt = 0);
 
     /**
      * Returns a block of memory to hold vertices. A buffer designated to hold
      * the vertices given to the caller. The buffer may or may not be locked.
      * The returned ptr remains valid until any of the following:
      *      *makeSpace is called again.
-     *      *unlock is called.
+     *      *unmap is called.
      *      *reset is called.
      *      *this object is destroyed.
      *
-     * Once unlock on the pool is called the vertices are guaranteed to be in
+     * Once unmap on the pool is called the vertices are guaranteed to be in
      * the buffer at the offset indicated by startVertex. Until that time they
      * may be in temporary storage and/or the buffer may be locked.
      *
      * @param vertexSize   specifies size of a vertex to allocate space for
      * @param vertexCount  number of vertices to allocate space for
      * @param buffer       returns the vertex buffer that will hold the
      *                     vertices.
      * @param startVertex  returns the offset into buffer of the first vertex.
      *                     In units of the size of a vertex from layout param.
      * @return pointer to first vertex.
@@ skipping 44 matching lines @@
 /**
  * A GrBufferAllocPool of index buffers
  */
 class GrIndexBufferAllocPool : public GrBufferAllocPool {
 public:
     /**
      * Constructor
      *
      * @param gpu                   The GrGpu used to create the index buffers.
      * @param frequentResetHint     A hint that indicates that the pool
-     *                              should expect frequent unlock() calls
+     *                              should expect frequent unmap() calls
      *                              (as opposed to many makeSpace / acquires
      *                              between resets).
      * @param bufferSize            The minimum size of created IBs This value
      *                              will be clamped to some reasonable minimum.
      * @param preallocBufferCnt     The pool will allocate this number of VBs at
      *                              bufferSize and keep them until it is
      *                              destroyed.
      */
     GrIndexBufferAllocPool(GrGpu* gpu,
                            bool frequentResetHint,
                            size_t bufferSize = 0,
                            int preallocBufferCnt = 0);
 
     /**
      * Returns a block of memory to hold indices. A buffer designated to hold
      * the indices is given to the caller. The buffer may or may not be locked.
      * The returned ptr remains valid until any of the following:
      *      *makeSpace is called again.
-     *      *unlock is called.
+     *      *unmap is called.
      *      *reset is called.
      *      *this object is destroyed.
      *
-     * Once unlock on the pool is called the indices are guaranteed to be in the
+     * Once unmap on the pool is called the indices are guaranteed to be in the
      * buffer at the offset indicated by startIndex. Until that time they may be
      * in temporary storage and/or the buffer may be locked.
      *
      * @param indexCount   number of indices to allocate space for
      * @param buffer       returns the index buffer that will hold the indices.
      * @param startIndex   returns the offset into buffer of the first index.
      * @return pointer to first index.
      */
     void* makeSpace(int indexCount,
                     const GrIndexBuffer** buffer,
@@ skipping 23 matching lines @@
      * @return number of indices that fit in one of the preallocated index
      *         buffers.
      */
     int preallocatedBufferIndices() const;
 
 private:
     typedef GrBufferAllocPool INHERITED;
 };
 
 #endif