Consolidate GPU buffer implementations

src/gpu/gl/GrGLGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLGpu_DEFINED
 #define GrGLGpu_DEFINED
 
 #include "GrGLContext.h"
 #include "GrGLIRect.h"
-#include "GrGLIndexBuffer.h"
 #include "GrGLPathRendering.h"
 #include "GrGLProgram.h"
 #include "GrGLRenderTarget.h"
 #include "GrGLStencilAttachment.h"
 #include "GrGLTexture.h"
-#include "GrGLTransferBuffer.h"
 #include "GrGLVertexArray.h"
-#include "GrGLVertexBuffer.h"
 #include "GrGpu.h"
 #include "GrPipelineBuilder.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "SkTArray.h"
 #include "SkTypes.h"
 
+class GrGLBuffer;
 class GrPipeline;
 class GrNonInstancedMesh;
 class GrSwizzle;
 
 #ifdef SK_DEVELOPER
 #define PROGRAM_CACHE_STATS
 #endif
 
 class GrGLGpu : public GrGpu {
 public:
@@ skipping 55 matching lines @@
     }
     void notifyIndexBufferDelete(GrGLuint id) {
         fHWGeometryState.notifyIndexBufferDelete(id);
     }
 
     // id and type (GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, etc.) of buffer to bind
     void bindBuffer(GrGLuint id, GrGLenum type);
 
     void releaseBuffer(GrGLuint id, GrGLenum type);
 
-    // sizes are in bytes
-    void* mapBuffer(GrGLuint id, GrGLenum type, GrGLBufferImpl::Usage usage, size_t currentSize,
-                    size_t requestedSize);
-
-    void unmapBuffer(GrGLuint id, GrGLenum type, void* mapPtr);
-
-    void bufferData(GrGLuint id, GrGLenum type, GrGLBufferImpl::Usage usage, size_t currentSize,
-                    const void* src, size_t srcSizeInBytes);
-
     const GrGLContext* glContextForTesting() const override {
         return &this->glContext();
     }
 
     void clearStencil(GrRenderTarget*) override;
 
     void invalidateBoundRenderTarget() {
         fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
     }
 
@@ skipping 19 matching lines @@
     void onResetContext(uint32_t resetBits) override;
 
     void xferBarrier(GrRenderTarget*, GrXferBarrierType) override;
 
     GrTexture* onCreateTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle lifeCycle,
                                const SkTArray<GrMipLevel>& texels) override;
     GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc,
                                          GrGpuResource::LifeCycle lifeCycle,
                                          const SkTArray<GrMipLevel>& texels) override;
 
-    GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) override;
-    GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) override;
-    GrTransferBuffer* onCreateTransferBuffer(size_t size, TransferType type) override;
+    GrBuffer* onCreateBuffer(GrBufferType, size_t size, GrAccessPattern) override;
     GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override;
     GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&,
                                               GrWrapOwnership) override;
     GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&,
                                                        GrWrapOwnership) override;
     // Given a GrPixelConfig return the index into the stencil format array on GrGLCaps to a
     // compatible stencil format, or negative if there is no compatible stencil format.
     int getCompatibleStencilIndex(GrPixelConfig config);
 
     // If |desc.fTextureStorageAllocator| exists, use that to create the
@@ skipping 36 matching lines @@
                       void* buffer,
                       size_t rowBytes) override;
 
     bool onWritePixels(GrSurface*,
                        int left, int top, int width, int height,
                        GrPixelConfig config,
                        const SkTArray<GrMipLevel>& texels) override;
 
     bool onTransferPixels(GrSurface*,
                           int left, int top, int width, int height,
-                          GrPixelConfig config, GrTransferBuffer* buffer,
+                          GrPixelConfig config, GrBuffer* transferBuffer,
                           size_t offset, size_t rowBytes) override;
 
     void onResolveRenderTarget(GrRenderTarget* target) override;
 
     void onDraw(const GrPipeline&,
                 const GrPrimitiveProcessor&,
                 const GrMesh*,
                 int meshCount) override;
 
     bool onCopySurface(GrSurface* dst,
@@ skipping 283 matching lines @@
             }
         }
 
         /**
          * Binds the vertex array object that should be used to render from the vertex buffer.
          * The vertex array is bound and its attrib array state object is returned. The vertex
          * buffer is bound. The index buffer (if non-nullptr) is bound to the vertex array. The
          * returned GrGLAttribArrayState should be used to set vertex attribute arrays.
          */
         GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGLGpu* gpu,
-                                                        const GrGLVertexBuffer* vbuffer,
-                                                        const GrGLIndexBuffer* ibuffer);
+                                                        const GrGLBuffer* vbuffer,
+                                                        const GrGLBuffer* ibuffer);
 
         /** Variants of the above that takes GL buffer IDs. Note that 0 does not imply that a 
             buffer won't be bound. The "default buffer" will be bound, which is used for client-side
             array rendering. */
         GrGLAttribArrayState* bindArrayAndBufferToDraw(GrGLGpu* gpu, GrGLuint vbufferID);
         GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGLGpu* gpu,
                                                         GrGLuint vbufferID,
                                                         GrGLuint ibufferID);
 
     private:
@@ skipping 91 matching lines @@
     } fPLSSetupProgram;
 
     bool fHWPLSEnabled;
     bool fPLSHasBeenUsed;
 
     typedef GrGpu INHERITED;
     friend class GrGLPathRendering; // For accessing setTextureUnit.
 };
 
 #endif