Revert of Start on simplifying generateGeometry() overrides

src/gpu/GrDefaultPathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDefaultPathRenderer.h"
 
 #include "GrBatch.h"
@@ skipping 311 matching lines @@
         void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
                                                               maxVertices,
                                                               &vertexBuffer,
                                                               &firstVertex);
 
         if (!vertices) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
-        const GrIndexBuffer* indexBuffer = NULL;
-        int firstIndex = 0;
+        const GrIndexBuffer* indexBuffer;
+        int firstIndex;
 
         void* indices = NULL;
         if (isIndexed) {
             indices = batchTarget->indexPool()->makeSpace(maxIndices,
                                                           &indexBuffer,
                                                           &firstIndex);
 
             if (!indices) {
                 SkDebugf("Could not allocate indices\n");
                 return;
@@ skipping 19 matching lines @@
                                   isIndexed)) {
                 return;
             }
 
             vertexOffset += vertexCnt;
             indexOffset += indexCnt;
             SkASSERT(vertexOffset <= maxVertices && indexOffset <= maxIndices);
         }
 
         GrDrawTarget::DrawInfo drawInfo;
+        drawInfo.setPrimitiveType(primitiveType);
+        drawInfo.setVertexBuffer(vertexBuffer);
+        drawInfo.setStartVertex(firstVertex);
+        drawInfo.setVertexCount(vertexOffset);
         if (isIndexed) {
-            drawInfo.initIndexed(primitiveType, vertexBuffer, indexBuffer, firstVertex, firstIndex,
-                                 vertexOffset, indexOffset);
+            drawInfo.setIndexBuffer(indexBuffer);
+            drawInfo.setStartIndex(firstIndex);
+            drawInfo.setIndexCount(indexOffset);
         } else {
-            drawInfo.init(primitiveType, vertexBuffer, firstVertex, vertexOffset);
+            drawInfo.setStartIndex(0);
+            drawInfo.setIndexCount(0);
         }
         batchTarget->draw(drawInfo);
 
         // put back reserves
         batchTarget->putBackIndices((size_t)(maxIndices - indexOffset));
         batchTarget->putBackVertices((size_t)(maxVertices - vertexOffset), (size_t)vertexStride);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
@@ skipping 353 matching lines @@
 
 void GrDefaultPathRenderer::onStencilPath(GrDrawTarget* target,
                                           GrPipelineBuilder* pipelineBuilder,
                                           const SkMatrix& viewMatrix,
                                           const SkPath& path,
                                           const GrStrokeInfo& stroke) {
     SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
     this->internalDrawPath(target, pipelineBuilder, GrColor_WHITE, viewMatrix, path, stroke, true);
 }