Revert of Consolidate GPU buffer implementations

src/gpu/GrGpu.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 "GrGpu.h"
 
-#include "GrBuffer.h"
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrGpuResourcePriv.h"
+#include "GrIndexBuffer.h"
 #include "GrMesh.h"
 #include "GrPathRendering.h"
 #include "GrPipeline.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "GrRenderTargetPriv.h"
 #include "GrStencilAttachment.h"
 #include "GrSurfacePriv.h"
+#include "GrTransferBuffer.h"
+#include "GrVertexBuffer.h"
 #include "SkTypes.h"
 
 GrMesh& GrMesh::operator =(const GrMesh& di) {
     fPrimitiveType  = di.fPrimitiveType;
     fStartVertex    = di.fStartVertex;
     fStartIndex     = di.fStartIndex;
     fVertexCount    = di.fVertexCount;
     fIndexCount     = di.fIndexCount;
 
     fInstanceCount          = di.fInstanceCount;
@@ skipping 196 matching lines @@
     if (!this->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
         return nullptr;
     }
     int maxSize = this->caps()->maxTextureSize();
     if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
         return nullptr;
     }
     return this->onWrapBackendTextureAsRenderTarget(desc, ownership);
 }
 
-GrBuffer* GrGpu::createBuffer(GrBufferType type, size_t size, GrAccessPattern accessPattern) {
+GrVertexBuffer* GrGpu::createVertexBuffer(size_t size, bool dynamic) {
     this->handleDirtyContext();
-    GrBuffer* buffer = this->onCreateBuffer(type, size, accessPattern);
+    GrVertexBuffer* vb = this->onCreateVertexBuffer(size, dynamic);
     if (!this->caps()->reuseScratchBuffers()) {
-        buffer->resourcePriv().removeScratchKey();
+        vb->resourcePriv().removeScratchKey();
     }
-    return buffer;
+    return vb;
+}
+
+GrIndexBuffer* GrGpu::createIndexBuffer(size_t size, bool dynamic) {
+    this->handleDirtyContext();
+    GrIndexBuffer* ib = this->onCreateIndexBuffer(size, dynamic);
+    if (!this->caps()->reuseScratchBuffers()) {
+        ib->resourcePriv().removeScratchKey();
+    }
+    return ib;
+}
+
+GrTransferBuffer* GrGpu::createTransferBuffer(size_t size, TransferType type) {
+    this->handleDirtyContext();
+    GrTransferBuffer* tb = this->onCreateTransferBuffer(size, type);
+    return tb;
 }
 
 void GrGpu::clear(const SkIRect& rect,
                   GrColor color,
                   GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     SkASSERT(SkIRect::MakeWH(renderTarget->width(), renderTarget->height()).contains(rect));
     this->handleDirtyContext();
     this->onClear(renderTarget, rect, color);
 }
@@ skipping 136 matching lines @@
     mipLevel.fPixels = buffer;
     mipLevel.fRowBytes = rowBytes;
     SkSTArray<1, GrMipLevel> texels;
     texels.push_back(mipLevel);
 
     return this->writePixels(surface, left, top, width, height, config, texels);
 }
 
 bool GrGpu::transferPixels(GrSurface* surface,
                            int left, int top, int width, int height,
-                           GrPixelConfig config, GrBuffer* transferBuffer,
+                           GrPixelConfig config, GrTransferBuffer* buffer,
                            size_t offset, size_t rowBytes) {
-    SkASSERT(transferBuffer);
+    SkASSERT(buffer);
 
     this->handleDirtyContext();
     if (this->onTransferPixels(surface, left, top, width, height, config,
-                               transferBuffer, offset, rowBytes)) {
+                               buffer, offset, rowBytes)) {
         fStats.incTransfersToTexture();
         return true;
     }
     return false;
 }
 
 void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
     SkASSERT(target);
     this->handleDirtyContext();
     this->onResolveRenderTarget(target);
@@ skipping 63 matching lines @@
     if (primProc.numAttribs() > this->caps()->maxVertexAttributes()) {
         fStats.incNumFailedDraws();
         return false;
     }
     this->handleDirtyContext();
 
     this->onDraw(pipeline, primProc, meshes, meshCount);
     return true;
 }