Make it possible to draw multiple paths at once to a draw target

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 368 matching lines @@
                 GrCrash("unknown geom src type");
         }
         draw->fIndexBuffer->ref();
     } else {
         draw->fIndexBuffer = NULL;
     }
 }
 
 GrInOrderDrawBuffer::StencilPath::StencilPath() {}
 GrInOrderDrawBuffer::DrawPath::DrawPath() {}
+GrInOrderDrawBuffer::DrawPaths::DrawPaths() {}
+GrInOrderDrawBuffer::DrawPaths::~DrawPaths() {
+    if (fTransforms) {
+        SkDELETE_ARRAY(fTransforms);
+    }
+    for (size_t i = 0; i < fPathCount; ++i) {
+        fPaths[i]->unref();
+    }
+    SkDELETE_ARRAY(fPaths);
+}
 
 void GrInOrderDrawBuffer::onStencilPath(const GrPath* path, SkPath::FillType fill) {
     if (this->needsNewClip()) {
         this->recordClip();
     }
     // Only compare the subset of GrDrawState relevant to path stenciling?
     if (this->needsNewState()) {
         this->recordState();
     }
     StencilPath* sp = this->recordStencilPath();
@@ skipping 13 matching lines @@
     }
     DrawPath* cp = this->recordDrawPath();
     cp->fPath.reset(path);
     path->ref();
     cp->fFill = fill;
     if (NULL != dstCopy) {
         cp->fDstCopy = *dstCopy;
     }
 }
 
+void GrInOrderDrawBuffer::onDrawPaths(size_t pathCount, const GrPath** paths,
+                                      const SkMatrix* transforms,
+                                      SkPath::FillType fill,
+                                      SkStrokeRec::Style stroke,
+                                      const GrDeviceCoordTexture* dstCopy) {
+    SkASSERT(pathCount);
+
+    if (this->needsNewClip()) {
+        this->recordClip();
+    }
+    if (this->needsNewState()) {
+        this->recordState();
+    }
+    DrawPaths* dp = this->recordDrawPaths();
+    dp->fPathCount = pathCount;
+    dp->fPaths = SkNEW_ARRAY(const GrPath*, pathCount);
+    memcpy(dp->fPaths, paths, sizeof(GrPath*) * pathCount);
+    for (size_t i = 0; i < pathCount; ++i) {
+        dp->fPaths[i]->ref();
+    }
+
+    dp->fTransforms = SkNEW_ARRAY(SkMatrix, pathCount);
+    memcpy(dp->fTransforms, transforms, sizeof(SkMatrix) * pathCount);
+
+    dp->fFill = fill;
+    dp->fStroke = stroke;
+
+    if (NULL != dstCopy) {
+        dp->fDstCopy = *dstCopy;
+    }
+}
+
 void GrInOrderDrawBuffer::clear(const SkIRect* rect, GrColor color,
                                 bool canIgnoreRect, GrRenderTarget* renderTarget) {
     SkIRect r;
     if (NULL == renderTarget) {
         renderTarget = this->drawState()->getRenderTarget();
         SkASSERT(NULL != renderTarget);
     }
     if (NULL == rect) {
         // We could do something smart and remove previous draws and clears to
         // the current render target. If we get that smart we have to make sure
@@ skipping 28 matching lines @@
     int numDraws = fDraws.count();
     for (int d = 0; d < numDraws; ++d) {
         // we always have a VB, but not always an IB
         SkASSERT(NULL != fDraws[d].fVertexBuffer);
         fDraws[d].fVertexBuffer->unref();
         SkSafeUnref(fDraws[d].fIndexBuffer);
     }
     fCmds.reset();
     fDraws.reset();
     fStencilPaths.reset();
+    fDrawPath.reset();
     fDrawPaths.reset();
     fStates.reset();
     fClears.reset();
     fVertexPool.reset();
     fIndexPool.reset();
     fClips.reset();
     fClipOrigins.reset();
     fCopySurfaces.reset();
     fClipSet = true;
 }
@@ skipping 26 matching lines @@
     fDstGpu->setDrawState(&playbackState);
 
     GrClipData clipData;
 
     int currState       = 0;
     int currClip        = 0;
     int currClear       = 0;
     int currDraw        = 0;
     int currStencilPath = 0;
     int currDrawPath    = 0;
+    int currDrawPaths   = 0;
     int currCopySurface = 0;
 
     for (int c = 0; c < numCmds; ++c) {
         switch (fCmds[c]) {
             case kDraw_Cmd: {
                 const DrawRecord& draw = fDraws[currDraw];
                 fDstGpu->setVertexSourceToBuffer(draw.fVertexBuffer);
                 if (draw.isIndexed()) {
                     fDstGpu->setIndexSourceToBuffer(draw.fIndexBuffer);
                 }
                 fDstGpu->executeDraw(draw);
 
                 ++currDraw;
                 break;
             }
             case kStencilPath_Cmd: {
                 const StencilPath& sp = fStencilPaths[currStencilPath];
                 fDstGpu->stencilPath(sp.fPath.get(), sp.fFill);
                 ++currStencilPath;
                 break;
             }
             case kDrawPath_Cmd: {
-                const DrawPath& cp = fDrawPaths[currDrawPath];
+                const DrawPath& cp = fDrawPath[currDrawPath];
                 fDstGpu->executeDrawPath(cp.fPath.get(), cp.fFill,
                                          NULL != cp.fDstCopy.texture() ? &cp.fDstCopy : NULL);
                 ++currDrawPath;
                 break;
             }
+            case kDrawPaths_Cmd: {
+                DrawPaths& dp = fDrawPaths[currDrawPaths];
+                const GrDeviceCoordTexture* dstCopy =
+                    NULL != dp.fDstCopy.texture() ? &dp.fDstCopy : NULL;
+                fDstGpu->executeDrawPaths(dp.fPathCount, dp.fPaths,
+                                          dp.fTransforms, dp.fFill, dp.fStroke,
+                                          dstCopy);
+                ++currDrawPaths;
+                break;
+            }
             case kSetState_Cmd:
                 fStates[currState].restoreTo(&playbackState);
                 ++currState;
                 break;
             case kSetClip_Cmd:
                 clipData.fClipStack = &fClips[currClip];
                 clipData.fOrigin = fClipOrigins[currClip];
                 fDstGpu->setClip(&clipData);
                 ++currClip;
                 break;
@@ skipping 292 matching lines @@
     return &fDraws.push_back(info);
 }
 
 GrInOrderDrawBuffer::StencilPath* GrInOrderDrawBuffer::recordStencilPath() {
     fCmds.push_back(kStencilPath_Cmd);
     return &fStencilPaths.push_back();
 }
 
 GrInOrderDrawBuffer::DrawPath* GrInOrderDrawBuffer::recordDrawPath() {
     fCmds.push_back(kDrawPath_Cmd);
+    return &fDrawPath.push_back();
+}
+
+GrInOrderDrawBuffer::DrawPaths* GrInOrderDrawBuffer::recordDrawPaths() {
+    fCmds.push_back(kDrawPaths_Cmd);
     return &fDrawPaths.push_back();
 }
 
 GrInOrderDrawBuffer::Clear* GrInOrderDrawBuffer::recordClear() {
     fCmds.push_back(kClear_Cmd);
     return &fClears.push_back();
 }
 
 GrInOrderDrawBuffer::CopySurface* GrInOrderDrawBuffer::recordCopySurface() {
     fCmds.push_back(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
 
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }