Remove unneeded features from GrBufferAllocPool

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
 
@@ skipping 58 matching lines @@
     enum BufferType {
         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 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,
                        BufferType bufferType,
-                       bool frequentResetHint,
                        size_t   bufferSize = 0,
                        int preallocBufferCnt = 0);
 
     virtual ~GrBufferAllocPool();
 
     /**
      * Gets the size of the preallocated buffers.
      *
      * @return the size of preallocated buffers.
      */
@@ skipping 36 matching lines @@
      * @return the number of items that would fit in the current buffer.
      */
     int currentBufferItems(size_t itemSize) const;
 
     GrGeometryBuffer* createBuffer(size_t size);
 
 private:
 
     // The GrGpu must be able to clear the ref of pools it creates as members
     friend class GrGpu;
-    void releaseGpuRef();
 
     struct BufferBlock {
         size_t              fBytesFree;
         GrGeometryBuffer*   fBuffer;
     };
 
     bool createBlock(size_t requestSize);
     void destroyBlock();
     void flushCpuData(const BufferBlock& block, size_t flushSize);
 #ifdef SK_DEBUG
     void validate(bool unusedBlockAllowed = false) const;
 #endif
 
     size_t                          fBytesInUse;
 
     GrGpu*                          fGpu;
-    bool                            fGpuIsReffed;
-    bool                            fFrequentResetHint;
     SkTDArray<GrGeometryBuffer*>    fPreallocBuffers;
     size_t                          fMinBlockSize;
     BufferType                      fBufferType;
 
     SkTArray<BufferBlock>           fBlocks;
     int                             fPreallocBuffersInUse;
     // We attempt to cycle through the preallocated buffers rather than
     // always starting from the first.
     int                             fPreallocBufferStartIdx;
     SkAutoMalloc                    fCpuData;
     void*                           fBufferPtr;
 };
 
 class GrVertexBuffer;
 
 /**
  * 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 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);
+    GrVertexBufferAllocPool(GrGpu* gpu, 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.
      *      *unmap is called.
      *      *reset is called.
      *      *this object is destroyed.
      *
@@ skipping 45 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 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.
      *      *unmap is called.
      *      *reset is called.
@@ skipping 28 matching lines @@
      * @return number of indices that fit in one of the preallocated index
      *         buffers.
      */
     int preallocatedBufferIndices() const;
 
 private:
     typedef GrBufferAllocPool INHERITED;
 };
 
 #endif