Consolidate GPU buffer implementations

src/gpu/batches/GrTessellatingPathRenderer.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 "GrTessellatingPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 27 matching lines @@
 public:
     explicit PathInvalidator(const GrUniqueKey& key) : fMsg(key) {}
 private:
     GrUniqueKeyInvalidatedMessage fMsg;
 
     void onChange() override {
         SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg);
     }
 };
 
-bool cache_match(GrVertexBuffer* vertexBuffer, SkScalar tol, int* actualCount) {
+bool cache_match(GrBuffer* vertexBuffer, SkScalar tol, int* actualCount) {
     if (!vertexBuffer) {
         return false;
     }
     const SkData* data = vertexBuffer->getUniqueKey().getCustomData();
     SkASSERT(data);
     const TessInfo* info = static_cast<const TessInfo*>(data->data());
     if (info->fTolerance == 0 || info->fTolerance < 3.0f * tol) {
         *actualCount = info->fCount;
         return true;
     }
     return false;
 }
 
 class StaticVertexAllocator : public GrTessellator::VertexAllocator {
 public:
     StaticVertexAllocator(GrResourceProvider* resourceProvider, bool canMapVB)
       : fResourceProvider(resourceProvider)
       , fCanMapVB(canMapVB)
       , fVertices(nullptr) {
     }
     SkPoint* lock(int vertexCount) override {
         size_t size = vertexCount * sizeof(SkPoint);
-        fVertexBuffer.reset(fResourceProvider->createVertexBuffer(
-            size, GrResourceProvider::kStatic_BufferUsage, 0));
+        fVertexBuffer.reset(fResourceProvider->createBuffer(
+            kVertex_GrBufferType, size, kStatic_GrAccessPattern, 0));
         if (!fVertexBuffer.get()) {
             return nullptr;
         }
         if (fCanMapVB) {
             fVertices = static_cast<SkPoint*>(fVertexBuffer->map());
         } else {
             fVertices = new SkPoint[vertexCount];
         }
         return fVertices;
     }
     void unlock(int actualCount) override {
         if (fCanMapVB) {
             fVertexBuffer->unmap();
         } else {
             fVertexBuffer->updateData(fVertices, actualCount * sizeof(SkPoint));
             delete[] fVertices;
         }
         fVertices = nullptr;
     }
-    GrVertexBuffer* vertexBuffer() { return fVertexBuffer.get(); }
+    GrBuffer* vertexBuffer() { return fVertexBuffer.get(); }
 private:
-    SkAutoTUnref<GrVertexBuffer> fVertexBuffer;
+    SkAutoTUnref<GrBuffer> fVertexBuffer;
     GrResourceProvider* fResourceProvider;
     bool fCanMapVB;
     SkPoint* fVertices;
 };
 
 }  // namespace
 
 GrTessellatingPathRenderer::GrTessellatingPathRenderer() {
 }
 
@@ skipping 46 matching lines @@
         GrUniqueKey::Builder builder(&key, kDomain, 2 + clipBoundsSize32 + strokeDataSize32);
         builder[0] = fPath.getGenerationID();
         builder[1] = fPath.getFillType();
         // For inverse fills, the tessellation is dependent on clip bounds.
         if (fPath.isInverseFillType()) {
             memcpy(&builder[2], &fClipBounds, sizeof(fClipBounds));
         }
         fStroke.asUniqueKeyFragment(&builder[2 + clipBoundsSize32]);
         builder.finish();
         GrResourceProvider* rp = target->resourceProvider();
-        SkAutoTUnref<GrVertexBuffer> cachedVertexBuffer(
-            rp->findAndRefTByUniqueKey<GrVertexBuffer>(key));
+        SkAutoTUnref<GrBuffer> cachedVertexBuffer(rp->findAndRefTByUniqueKey<GrBuffer>(key));
         int actualCount;
         SkScalar screenSpaceTol = GrPathUtils::kDefaultTolerance;
         SkScalar tol = GrPathUtils::scaleToleranceToSrc(
             screenSpaceTol, fViewMatrix, fPath.getBounds());
         if (cache_match(cachedVertexBuffer.get(), tol, &actualCount)) {
             this->drawVertices(target, gp, cachedVertexBuffer.get(), 0, actualCount);
             return;
         }
 
         SkPath path;
@@ skipping 46 matching lines @@
             } else {
                 coverageType = Coverage::kNone_Type;
             }
             Coverage coverage(coverageType);
             gp.reset(GrDefaultGeoProcFactory::Create(color, coverage, localCoords,
                                                      fViewMatrix));
         }
         this->draw(target, gp.get());
     }
 
-    void drawVertices(Target* target, const GrGeometryProcessor* gp, const GrVertexBuffer* vb,
+    void drawVertices(Target* target, const GrGeometryProcessor* gp, const GrBuffer* vb,
                       int firstVertex, int count) const {
         SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
 
         GrPrimitiveType primitiveType = TESSELLATOR_WIREFRAME ? kLines_GrPrimitiveType
                                                               : kTriangles_GrPrimitiveType;
         target->initDraw(gp);
 
         GrMesh mesh;
         mesh.init(primitiveType, vb, firstVertex, count);
         target->draw(mesh);
@@ skipping 82 matching lines @@
     bool result = viewMatrix.invert(&vmi);
     if (!result) {
         SkFAIL("Cannot invert matrix\n");
     }
     vmi.mapRect(&clipBounds);
     GrStrokeInfo strokeInfo = GrTest::TestStrokeInfo(random);
     return TessellatingPathBatch::Create(color, path, strokeInfo, viewMatrix, clipBounds);
 }
 
 #endif