Reduce integer divides in GrAllocator

src/gpu/GrInOrderDrawBuffer.cpp

Index: src/gpu/GrInOrderDrawBuffer.cpp
diff --git a/src/gpu/GrInOrderDrawBuffer.cpp b/src/gpu/GrInOrderDrawBuffer.cpp
index deea72b90d961197fb148a4f0bf5090078122d34..9d77e78d678cb66f79b408db9029ddd94902561f 100644
--- a/src/gpu/GrInOrderDrawBuffer.cpp
+++ b/src/gpu/GrInOrderDrawBuffer.cpp
@@ -530,12 +530,13 @@ void GrInOrderDrawBuffer::reset() {
     SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();
-    int numDraws = fDraws.count();
-    for (int d = 0; d < numDraws; ++d) {
+        
+    DrawAllocator::Iter draw(&fDraws);
+    while (draw.next()) {
         // we always have a VB, but not always an IB
-        SkASSERT(NULL != fDraws[d].fVertexBuffer);
-        fDraws[d].fVertexBuffer->unref();
-        SkSafeUnref(fDraws[d].fIndexBuffer);
+        SkASSERT(NULL != draw.get().fVertexBuffer);
+        draw.get().fVertexBuffer->unref();
+        SkSafeUnref(draw.get().fIndexBuffer);
     }
     fCmds.reset();
     fDraws.reset();
@@ -584,14 +585,16 @@ void GrInOrderDrawBuffer::flush() {
 
     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;
+    StateAllocator::Iter stateIter(&fStates);
+    ClipAllocator::Iter clipIter(&fClips);
+    ClipOriginAllocator::Iter clipOriginIter(&fClipOrigins);
+    ClearAllocator::Iter clearIter(&fClears);
+    DrawAllocator::Iter drawIter(&fDraws);
+    StencilPathAllocator::Iter stencilPathIter(&fStencilPaths);
+    DrawPathAllocator::Iter drawPathIter(&fDrawPath);
+    DrawPathsAllocator::Iter drawPathsIter(&fDrawPaths);
+    CopySurfaceAllocator::Iter copySurfaceIter(&fCopySurfaces);
+
     int currCmdMarker   = 0;
 
     fDstGpu->saveActiveTraceMarkers();
@@ -605,65 +608,66 @@ void GrInOrderDrawBuffer::flush() {
         }
         switch (strip_trace_bit(fCmds[c])) {
             case kDraw_Cmd: {
-                const DrawRecord& draw = fDraws[currDraw];
+                SkAssertResult(drawIter.next());
+                const DrawRecord& draw = drawIter.get();
                 fDstGpu->setVertexSourceToBuffer(draw.fVertexBuffer);
                 if (draw.isIndexed()) {
                     fDstGpu->setIndexSourceToBuffer(draw.fIndexBuffer);
                 }
                 fDstGpu->executeDraw(draw);
-                ++currDraw;
                 break;
             }
             case kStencilPath_Cmd: {
-                const StencilPath& sp = fStencilPaths[currStencilPath];
+                SkAssertResult(stencilPathIter.next());
+                const StencilPath& sp = stencilPathIter.get();
                 fDstGpu->stencilPath(sp.fPath.get(), sp.fFill);
-                ++currStencilPath;
                 break;
             }
             case kDrawPath_Cmd: {
-                const DrawPath& cp = fDrawPath[currDrawPath];
+                SkAssertResult(drawPathIter.next());
+                const DrawPath& cp = drawPathIter.get();
                 fDstGpu->executeDrawPath(cp.fPath.get(), cp.fFill,
                                          NULL != cp.fDstCopy.texture() ? &cp.fDstCopy : NULL);
-                ++currDrawPath;
                 break;
             }
             case kDrawPaths_Cmd: {
-                DrawPaths& dp = fDrawPaths[currDrawPaths];
+                SkAssertResult(drawPathsIter.next());
+                const DrawPaths& dp = drawPathsIter.get();
                 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;
+                SkAssertResult(stateIter.next());
+                stateIter.get().restoreTo(&playbackState);
                 break;
             case kSetClip_Cmd:
-                clipData.fClipStack = &fClips[currClip];
-                clipData.fOrigin = fClipOrigins[currClip];
+                SkAssertResult(clipIter.next());
+                SkAssertResult(clipOriginIter.next());
+                clipData.fClipStack = &clipIter.get();
+                clipData.fOrigin = clipOriginIter.get();
                 fDstGpu->setClip(&clipData);
-                ++currClip;
                 break;
             case kClear_Cmd:
-                if (GrColor_ILLEGAL == fClears[currClear].fColor) {
-                    fDstGpu->discard(fClears[currClear].fRenderTarget);
+                SkAssertResult(clearIter.next());
+                if (GrColor_ILLEGAL == clearIter.get().fColor) {
+                    fDstGpu->discard(clearIter.get().fRenderTarget);
                 } else {
-                    fDstGpu->clear(&fClears[currClear].fRect,
-                                   fClears[currClear].fColor,
-                                   fClears[currClear].fCanIgnoreRect,
-                                   fClears[currClear].fRenderTarget);
+                    fDstGpu->clear(&clearIter.get().fRect,
+                                   clearIter.get().fColor,
+                                   clearIter.get().fCanIgnoreRect,
+                                   clearIter.get().fRenderTarget);
                 }
-                ++currClear;
                 break;
             case kCopySurface_Cmd:
-                fDstGpu->copySurface(fCopySurfaces[currCopySurface].fDst.get(),
-                                     fCopySurfaces[currCopySurface].fSrc.get(),
-                                     fCopySurfaces[currCopySurface].fSrcRect,
-                                     fCopySurfaces[currCopySurface].fDstPoint);
-                ++currCopySurface;
+                SkAssertResult(copySurfaceIter.next());
+                fDstGpu->copySurface(copySurfaceIter.get().fDst.get(),
+                                     copySurfaceIter.get().fSrc.get(),
+                                     copySurfaceIter.get().fSrcRect,
+                                     copySurfaceIter.get().fDstPoint);
                 break;
         }
         if (cmd_has_trace_marker(fCmds[c])) {
@@ -672,12 +676,16 @@ void GrInOrderDrawBuffer::flush() {
     }
     fDstGpu->restoreActiveTraceMarkers();
     // we should have consumed all the states, clips, etc.
-    SkASSERT(fStates.count() == currState);
-    SkASSERT(fClips.count() == currClip);
-    SkASSERT(fClipOrigins.count() == currClip);
-    SkASSERT(fClears.count() == currClear);
-    SkASSERT(fDraws.count()  == currDraw);
-    SkASSERT(fCopySurfaces.count() == currCopySurface);
+    SkASSERT(!stateIter.next());
+    SkASSERT(!clipIter.next());
+    SkASSERT(!clipOriginIter.next());
+    SkASSERT(!clearIter.next());
+    SkASSERT(!drawIter.next());
+    SkASSERT(!copySurfaceIter.next());
+    SkASSERT(!stencilPathIter.next());
+    SkASSERT(!drawPathIter.next());
+    SkASSERT(!drawPathsIter.next());
+
     SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
 
     fDstGpu->setDrawState(prevDrawState);