Isolate GrBufferAllocPools inside GrBatchTarget

src/gpu/GrAAConvexPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexPathRenderer.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
-#include "GrBufferAllocPool.h"
 #include "GrContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGeometryProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrPathUtils.h"
 #include "GrProcessor.h"
 #include "GrPipelineBuilder.h"
 #include "GrStrokeInfo.h"
 #include "SkGeometry.h"
 #include "SkString.h"
@@ skipping 764 matching lines @@
 
             if (!get_segments(args.fPath, *viewMatrix, &segments, &fanPt, &vertexCount,
                               &indexCount)) {
                 continue;
             }
 
             const GrVertexBuffer* vertexBuffer;
             int firstVertex;
 
             size_t vertexStride = quadProcessor->getVertexStride();
-            void *vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
-                                                                  vertexCount,
-                                                                  &vertexBuffer,
-                                                                  &firstVertex);
-
+            void *vertices = batchTarget->makeVertSpace(vertexStride, vertexCount,
+                                                        &vertexBuffer, &firstVertex);
             if (!vertices) {
                 SkDebugf("Could not allocate vertices\n");
                 return;
             }
 
             const GrIndexBuffer* indexBuffer;
             int firstIndex;
 
-            void *indices = batchTarget->indexPool()->makeSpace(indexCount,
-                                                                &indexBuffer,
-                                                                &firstIndex);
-
-            if (!indices) {
+            uint16_t *idxs = batchTarget->makeIndexSpace(indexCount, &indexBuffer, &firstIndex);
+            if (!idxs) {
                 SkDebugf("Could not allocate indices\n");
                 return;
             }
 
             QuadVertex* verts = reinterpret_cast<QuadVertex*>(vertices);
-            uint16_t* idxs = reinterpret_cast<uint16_t*>(indices);
 
             SkSTArray<kPreallocDrawCnt, Draw, true> draws;
             create_vertices(segments, fanPt, &draws, verts, idxs);
 
             GrVertices info;
 
             for (int i = 0; i < draws.count(); ++i) {
                 const Draw& draw = draws[i];
                 info.initIndexed(kTriangles_GrPrimitiveType, vertexBuffer, indexBuffer, firstVertex,
                                  firstIndex, draw.fVertexCnt, draw.fIndexCnt);
@@ skipping 63 matching lines @@
     geometry.fColor = color;
     geometry.fViewMatrix = vm;
     geometry.fPath = path;
 
     SkAutoTUnref<GrBatch> batch(AAConvexPathBatch::Create(geometry));
     target->drawBatch(pipelineBuilder, batch);
 
     return true;
 
 }