Consolidate GPU buffer implementations

src/gpu/batches/GrPLSPathRenderer.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPLSPathRenderer.h"
 
 #include "SkChunkAlloc.h"
@@ skipping 855 matching lines @@
 
             GrMesh mesh;
 
             PLSVertices triVertices;
             PLSVertices quadVertices;
             if (!get_geometry(*pathPtr, *viewMatrix, triVertices, quadVertices, rp, bounds)) {
                 continue;
             }
 
             if (triVertices.count()) {
-                const GrVertexBuffer* triVertexBuffer;
+                const GrBuffer* triVertexBuffer;
                 int firstTriVertex;
                 size_t triStride = triangleProcessor->getVertexStride();
                 PLSVertex* triVerts = reinterpret_cast<PLSVertex*>(target->makeVertexSpace(
                         triStride, triVertices.count(), &triVertexBuffer, &firstTriVertex));
                 if (!triVerts) {
                     SkDebugf("Could not allocate vertices\n");
                     return;
                 }
                 for (int i = 0; i < triVertices.count(); ++i) {
                     triVerts[i] = triVertices[i];
                 }
                 mesh.init(kTriangles_GrPrimitiveType, triVertexBuffer, firstTriVertex,
                           triVertices.count());
                 target->initDraw(triangleProcessor);
                 target->draw(mesh);
             }
 
             if (quadVertices.count()) {
-                const GrVertexBuffer* quadVertexBuffer;
+                const GrBuffer* quadVertexBuffer;
                 int firstQuadVertex;
                 size_t quadStride = quadProcessor->getVertexStride();
                 PLSVertex* quadVerts = reinterpret_cast<PLSVertex*>(target->makeVertexSpace(
                         quadStride, quadVertices.count(), &quadVertexBuffer, &firstQuadVertex));
                 if (!quadVerts) {
                     SkDebugf("Could not allocate vertices\n");
                     return;
                 }
                 for (int i = 0; i < quadVertices.count(); ++i) {
                     quadVerts[i] = quadVertices[i];
                 }
                 mesh.init(kTriangles_GrPrimitiveType, quadVertexBuffer, firstQuadVertex,
                           quadVertices.count());
                 target->initDraw(quadProcessor);
                 target->draw(mesh);
             }
 
             SkAutoTUnref<GrGeometryProcessor> finishProcessor(
                     PLSFinishEffect::Create(this->color(), 
                                             pathPtr->getFillType() == 
                                                                 SkPath::FillType::kEvenOdd_FillType,
                                             invert, 
                                             this->usesLocalCoords()));
-            const GrVertexBuffer* rectVertexBuffer;
+            const GrBuffer* rectVertexBuffer;
             size_t finishStride = finishProcessor->getVertexStride();
             int firstRectVertex;
             static const int kRectVertexCount = 6;
             SkPoint* rectVerts = reinterpret_cast<SkPoint*>(target->makeVertexSpace(
                     finishStride, kRectVertexCount, &rectVertexBuffer, &firstRectVertex));
             if (!rectVerts) {
                 SkDebugf("Could not allocate vertices\n");
                 return;
             }
             rectVerts[0] = { bounds.fLeft, bounds.fTop };
@@ skipping 72 matching lines @@
 DRAW_BATCH_TEST_DEFINE(PLSPathBatch) {
     PLSPathBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
     geometry.fPath = GrTest::TestPathConvex(random);
 
     return PLSPathBatch::Create(geometry);
 }
 
 #endif