Move instanced index buffer creation to flush time

src/gpu/effects/GrDashingEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDashingEffect.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrBatchTest.h"
 #include "GrBufferAllocPool.h"
 #include "GrGeometryProcessor.h"
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTarget.h"
 #include "GrDrawTargetCaps.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
+#include "GrResourceProvider.h"
 #include "GrStrokeInfo.h"
 #include "GrVertexBuffer.h"
 #include "SkGr.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLSL.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 496 matching lines @@
             draw.fStartOffset = startOffset;
             draw.fDevBloatX = devBloatX;
             draw.fDevBloatY = devBloatY;
             draw.fHalfDevStroke = halfDevStroke;
             draw.fStrokeWidth = strokeWidth;
             draw.fHasStartRect = hasStartRect;
             draw.fLineDone = lineDone;
             draw.fHasEndRect = hasEndRect;
         }
 
+        SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+            batchTarget->resourceProvider()->refQuadIndexBuffer());
+
         const GrVertexBuffer* vertexBuffer;
         int firstVertex;
-
         size_t vertexStride = gp->getVertexStride();
         void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
                                                               totalRectCount * kVertsPerDash,
                                                               &vertexBuffer,
                                                               &firstVertex);
-
-        if (!vertices || !batchTarget->quadIndexBuffer()) {
+        if (!vertices || !indexBuffer) {
             SkDebugf("Could not allocate buffers\n");
             return;
         }
 
         int curVIdx = 0;
         int rectIndex = 0;
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
 
             if (!draws[i].fLineDone) {
@@ skipping 42 matching lines @@
                 } else {
                     SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
                     SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
                     setup_dashed_rect_pos(rects[rectIndex], curVIdx, args.fSrcRotInv, verts);
                 }
                 curVIdx += 4;
             }
             rectIndex++;
         }
 
-        const GrIndexBuffer* dashIndexBuffer = batchTarget->quadIndexBuffer();
-
         GrDrawTarget::DrawInfo drawInfo;
         drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
         drawInfo.setStartVertex(0);
         drawInfo.setStartIndex(0);
         drawInfo.setVerticesPerInstance(kVertsPerDash);
         drawInfo.setIndicesPerInstance(kIndicesPerDash);
         drawInfo.adjustStartVertex(firstVertex);
         drawInfo.setVertexBuffer(vertexBuffer);
-        drawInfo.setIndexBuffer(dashIndexBuffer);
+        drawInfo.setIndexBuffer(indexBuffer);
 
-        int maxInstancesPerDraw = dashIndexBuffer->maxQuads();
+        int maxInstancesPerDraw = indexBuffer->maxQuads();
         while (totalRectCount) {
             drawInfo.setInstanceCount(SkTMin(totalRectCount, maxInstancesPerDraw));
             drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
             drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
 
             batchTarget->draw(drawInfo);
 
             drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
             totalRectCount -= drawInfo.instanceCount();
        }
@@ skipping 121 matching lines @@
 
     geometry.fColor = color;
     geometry.fViewMatrix = viewMatrix;
     geometry.fPhase = info.fPhase;
     geometry.fIntervals[0] = info.fIntervals[0];
     geometry.fIntervals[1] = info.fIntervals[1];
 
     return DashBatch::Create(geometry, cap, aaMode, fullDash);
 }
 
-bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target,
+bool GrDashingEffect::DrawDashLine(GrDrawTarget* target,
                                    GrPipelineBuilder* pipelineBuilder, GrColor color,
                                    const SkMatrix& viewMatrix, const SkPoint pts[2],
                                    bool useAA, const GrStrokeInfo& strokeInfo) {
     SkAutoTUnref<GrBatch> batch(create_batch(color, viewMatrix, pts, useAA, strokeInfo,
                                              pipelineBuilder->getRenderTarget()->isMultisampled()));
     if (!batch) {
         return false;
     }
 
     target->drawBatch(pipelineBuilder, batch);
@@ skipping 597 matching lines @@
     info.fIntervals = intervals;
     info.fCount = 2;
     info.fPhase = phase;
     SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
     SkASSERT(success);
 
     return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
 }
 
 #endif