Minor cleanup of GrInOrderDrawBuffer

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 "GrBufferAllocPool.h"
@@ skipping 308 matching lines @@
 
     SkRect bounds = rect;
     viewMatrix.mapRect(&bounds);
     this->drawBatch(pipelineBuilder, batch, &bounds);
 }
 
 int GrInOrderDrawBuffer::concatInstancedDraw(const DrawInfo& info) {
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(info.isInstanced());
 
-    const GeometrySrcState& geomSrc = this->getGeomSrc();
-
-    // we only attempt to concat the case when reserved verts are used with a client-specified index
-    // buffer. To make this work with client-specified VBs we'd need to know if the VB was updated
-    // between draws.
-    if (kReserved_GeometrySrcType != geomSrc.fVertexSrc ||
-        kBuffer_GeometrySrcType != geomSrc.fIndexSrc) {
+    const GrIndexBuffer* ib;
+    if (!this->canConcatToIndexBuffer(&ib)) {
         return 0;
     }
+
     // Check if there is a draw info that is compatible that uses the same VB from the pool and
     // the same IB
     if (Cmd::kDraw_Cmd != fCmdBuffer.back().type()) {
         return 0;
     }
 
     Draw* draw = static_cast<Draw*>(&fCmdBuffer.back());
 
     if (!draw->fInfo.isInstanced() ||
         draw->fInfo.primitiveType() != info.primitiveType() ||
         draw->fInfo.verticesPerInstance() != info.verticesPerInstance() ||
         draw->fInfo.indicesPerInstance() != info.indicesPerInstance() ||
         draw->fInfo.vertexBuffer() != info.vertexBuffer() ||
-        draw->fInfo.indexBuffer() != geomSrc.fIndexBuffer) {
+        draw->fInfo.indexBuffer() != ib) {
         return 0;
     }
     if (draw->fInfo.startVertex() + draw->fInfo.vertexCount() != info.startVertex()) {
         return 0;
     }
 
     // how many instances can be concat'ed onto draw given the size of the index buffer
     int instancesToConcat = this->indexCountInCurrentSource() / info.indicesPerInstance();
     instancesToConcat -= draw->fInfo.instanceCount();
     instancesToConcat = SkTMin(instancesToConcat, info.instanceCount());
@@ skipping 94 matching lines @@
                                       const PipelineInfo& pipelineInfo) {
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transformValues);
     this->closeBatch();
 
     if (!this->setupPipelineAndShouldDraw(pathProc, pipelineInfo)) {
         return;
     }
 
-    int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
-    char* savedIndices = (char*) fPathIndexBuffer.alloc(count * indexBytes,
-                                                        SkChunkAlloc::kThrow_AllocFailType);
-    SkASSERT(SkIsAlign4((uintptr_t)savedIndices));
-    memcpy(savedIndices, reinterpret_cast<const char*>(indices), count * indexBytes);
+    char* savedIndices;
+    float* savedTransforms;
 
-    const int xformSize = GrPathRendering::PathTransformSize(transformType);
-    const int xformBytes = xformSize * sizeof(float);
-    float* savedTransforms = NULL;
-    if (0 != xformBytes) {
-        savedTransforms = (float*) fPathTransformBuffer.alloc(count * xformBytes,
-                                                              SkChunkAlloc::kThrow_AllocFailType);
-        SkASSERT(SkIsAlign4((uintptr_t)savedTransforms));
-        memcpy(savedTransforms, transformValues, count * xformBytes);
-    }
+    this->appendIndicesAndTransforms(indices, indexType,
+                                     transformValues, transformType,
+                                     count, &savedIndices, &savedTransforms);
 
     if (Cmd::kDrawPaths_Cmd == fCmdBuffer.back().type()) {
         // The previous command was also DrawPaths. Try to collapse this call into the one
         // before. Note that stenciling all the paths at once, then covering, may not be
         // equivalent to two separate draw calls if there is overlap. Blending won't work,
         // and the combined calls may also cancel each other's winding numbers in some
         // places. For now the winding numbers are only an issue if the fill is even/odd,
         // because DrawPaths is currently only used for glyphs, and glyphs in the same
         // font tend to all wind in the same direction.
         DrawPaths* previous = static_cast<DrawPaths*>(&fCmdBuffer.back());
         if (pathRange == previous->pathRange() &&
             indexType == previous->fIndexType &&
             transformType == previous->fTransformType &&
             stencilSettings == previous->fStencilSettings &&
             path_fill_type_is_winding(stencilSettings) &&
             !pipelineInfo.willBlendWithDst(pathProc)) {
+            const int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
+            const int xformSize = GrPathRendering::PathTransformSize(transformType);
             if (&previous->fIndices[previous->fCount*indexBytes] == savedIndices &&
-                (0 == xformBytes ||
+                (0 == xformSize ||
                  &previous->fTransforms[previous->fCount*xformSize] == savedTransforms)) {
                 // Fold this DrawPaths call into the one previous.
                 previous->fCount += count;
                 return;
             }
         }
     }
 
     DrawPaths* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPaths, (pathRange));
     dp->fIndices = savedIndices;
@@ skipping 263 matching lines @@
     }
 }
 
 void GrInOrderDrawBuffer::willReserveVertexAndIndexSpace(int vertexCount,
                                                          size_t vertexStride,
                                                          int indexCount) {
     this->closeBatch();
 
     this->INHERITED::willReserveVertexAndIndexSpace(vertexCount, vertexStride, indexCount);
 }