Revert of Consolidate GPU buffer implementations

src/gpu/batches/GrAAStrokeRectBatch.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 "GrAAStrokeRectBatch.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 105 matching lines @@
     }
 
     static const int kMiterIndexCnt = 3 * 24;
     static const int kMiterVertexCnt = 16;
     static const int kNumMiterRectsInIndexBuffer = 256;
 
     static const int kBevelIndexCnt = 48 + 36 + 24;
     static const int kBevelVertexCnt = 24;
     static const int kNumBevelRectsInIndexBuffer = 256;
 
-    static const GrBuffer* GetIndexBuffer(GrResourceProvider* resourceProvider, bool miterStroke);
+    static const GrIndexBuffer* GetIndexBuffer(GrResourceProvider* resourceProvider,
+                                               bool miterStroke);
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
     const Geometry& geometry() const { return fGeoData[0]; }
     const SkMatrix& viewMatrix() const { return fViewMatrix; }
     bool miterStroke() const { return fMiterStroke; }
 
@@ skipping 61 matching lines @@
 
     SkASSERT(canTweakAlphaForCoverage ?
              vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
              vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
     int innerVertexNum = 4;
     int outerVertexNum = this->miterStroke() ? 4 : 8;
     int verticesPerInstance = (outerVertexNum + innerVertexNum) * 2;
     int indicesPerInstance = this->miterStroke() ? kMiterIndexCnt : kBevelIndexCnt;
     int instanceCount = fGeoData.count();
 
-    const SkAutoTUnref<const GrBuffer> indexBuffer(
+    const SkAutoTUnref<const GrIndexBuffer> indexBuffer(
         GetIndexBuffer(target->resourceProvider(), this->miterStroke()));
     InstancedHelper helper;
     void* vertices = helper.init(target, kTriangles_GrPrimitiveType, vertexStride,
                                  indexBuffer, verticesPerInstance, indicesPerInstance,
                                  instanceCount);
     if (!vertices || !indexBuffer) {
          SkDebugf("Could not allocate vertices\n");
          return;
      }
 
     for (int i = 0; i < instanceCount; i++) {
         const Geometry& args = fGeoData[i];
         this->generateAAStrokeRectGeometry(vertices,
                                            i * verticesPerInstance * vertexStride,
                                            vertexStride,
                                            outerVertexNum,
                                            innerVertexNum,
                                            args.fColor,
                                            args.fDevOutside,
                                            args.fDevOutsideAssist,
                                            args.fDevInside,
                                            fMiterStroke,
                                            args.fDegenerate,
                                            canTweakAlphaForCoverage);
     }
     helper.recordDraw(target);
 }
 
-const GrBuffer* AAStrokeRectBatch::GetIndexBuffer(GrResourceProvider* resourceProvider,
-                                                  bool miterStroke) {
+const GrIndexBuffer* AAStrokeRectBatch::GetIndexBuffer(GrResourceProvider* resourceProvider,
+                                                       bool miterStroke) {
 
     if (miterStroke) {
         static const uint16_t gMiterIndices[] = {
             0 + 0, 1 + 0, 5 + 0, 5 + 0, 4 + 0, 0 + 0,
             1 + 0, 2 + 0, 6 + 0, 6 + 0, 5 + 0, 1 + 0,
             2 + 0, 3 + 0, 7 + 0, 7 + 0, 6 + 0, 2 + 0,
             3 + 0, 0 + 0, 4 + 0, 4 + 0, 7 + 0, 3 + 0,
 
             0 + 4, 1 + 4, 5 + 4, 5 + 4, 4 + 4, 0 + 4,
             1 + 4, 2 + 4, 6 + 4, 6 + 4, 5 + 4, 1 + 4,
@@ skipping 405 matching lines @@
     SkRect inside = outside;
     inside.inset(strokeWidth, strokeWidth);
 
     GrColor color = GrRandomColor(random);
 
     return GrAAStrokeRectBatch::Create(color, GrTest::TestMatrix(random), outside, outsideAssist,
                                        inside, miterStroke, inside.isFinite() && inside.isEmpty());
 }
 
 #endif