Revert of Move instanced index buffer creation to flush time

src/gpu/GrInOrderDrawBuffer.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 "GrInOrderDrawBuffer.h"
 
 #include "GrDefaultGeoProcFactory.h"
-#include "GrResourceProvider.h"
 #include "GrTemplates.h"
 
 GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrContext* context,
                                          GrVertexBufferAllocPool* vertexPool,
                                          GrIndexBufferAllocPool* indexPool)
     : INHERITED(context, vertexPool, indexPool)
     , fCommands(context->getGpu(), vertexPool, indexPool)
     , fPathIndexBuffer(kPathIdxBufferMinReserve * sizeof(char)/4)
     , fPathTransformBuffer(kPathXformBufferMinReserve * sizeof(float)/4)
     , fDrawID(0) {
@@ skipping 109 matching lines @@
         init.fUsesLocalCoords = this->usesLocalCoords();
         gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
 
         size_t vertexStride = gp->getVertexStride();
 
         SkASSERT(hasExplicitLocalCoords ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
 
         int instanceCount = fGeoData.count();
-        SkAutoTUnref<const GrIndexBuffer> indexBuffer(
-            batchTarget->resourceProvider()->refQuadIndexBuffer());
+        int vertexCount = kVertsPerRect * instanceCount;
 
-        int vertexCount = kVertsPerRect * instanceCount;
         const GrVertexBuffer* vertexBuffer;
         int firstVertex;
+
         void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
                                                               vertexCount,
                                                               &vertexBuffer,
                                                               &firstVertex);
 
-        if (!vertices || !indexBuffer) {
+        if (!vertices || !batchTarget->quadIndexBuffer()) {
             SkDebugf("Could not allocate buffers\n");
             return;
         }
 
         for (int i = 0; i < instanceCount; i++) {
             const Geometry& args = fGeoData[i];
 
             intptr_t offset = GrTCast<intptr_t>(vertices) + kVertsPerRect * i * vertexStride;
             SkPoint* positions = GrTCast<SkPoint*>(offset);
 
@@ skipping 13 matching lines @@
             }
 
             static const int kColorOffset = sizeof(SkPoint);
             GrColor* vertColor = GrTCast<GrColor*>(offset + kColorOffset);
             for (int j = 0; j < 4; ++j) {
                 *vertColor = args.fColor;
                 vertColor = (GrColor*) ((intptr_t) vertColor + vertexStride);
             }
         }
 
+        const GrIndexBuffer* quadIndexBuffer = batchTarget->quadIndexBuffer();
+
         GrDrawTarget::DrawInfo drawInfo;
         drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
         drawInfo.setStartVertex(0);
         drawInfo.setStartIndex(0);
         drawInfo.setVerticesPerInstance(kVertsPerRect);
         drawInfo.setIndicesPerInstance(kIndicesPerRect);
         drawInfo.adjustStartVertex(firstVertex);
         drawInfo.setVertexBuffer(vertexBuffer);
-        drawInfo.setIndexBuffer(indexBuffer);
+        drawInfo.setIndexBuffer(quadIndexBuffer);
 
-        int maxInstancesPerDraw = indexBuffer->maxQuads();
+        int maxInstancesPerDraw = quadIndexBuffer->maxQuads();
         while (instanceCount) {
             drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
             drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
             drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
 
             batchTarget->draw(drawInfo);
 
             drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
             instanceCount -= drawInfo.instanceCount();
        }
@@ skipping 186 matching lines @@
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         if (cmd->isTraced()) {
             fGpuCmdMarkers[cmd->markerID()].addSet(activeTraceMarkers);
         } else {
             cmd->setMarkerID(fGpuCmdMarkers.count());
             fGpuCmdMarkers.push_back(activeTraceMarkers);
         }
     }
 }