Reduce integer divides in GrAllocator

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 512 matching lines @@
     Clear* clr = this->recordClear();
     clr->fColor = GrColor_ILLEGAL;
     clr->fRenderTarget = renderTarget;
     renderTarget->ref();
 }
 
 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();
     fStencilPaths.reset();
     fDrawPath.reset();
     fDrawPaths.reset();
     fStates.reset();
     fClears.reset();
     fVertexPool.reset();
     fIndexPool.reset();
@@ skipping 28 matching lines @@
     GrDrawTarget::AutoClipRestore acr(fDstGpu);
     AutoGeometryAndStatePush agasp(fDstGpu, kPreserve_ASRInit);
 
     GrDrawState playbackState;
     GrDrawState* prevDrawState = fDstGpu->drawState();
     prevDrawState->ref();
     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;
+    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();
     for (int c = 0; c < numCmds; ++c) {
         GrGpuTraceMarker newMarker("", -1);
         if (cmd_has_trace_marker(fCmds[c])) {
             SkString traceString = fGpuCmdMarkers[currCmdMarker].toString();
             newMarker.fMarker = traceString.c_str();
             fDstGpu->addGpuTraceMarker(&newMarker);
             ++currCmdMarker;
         }
         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])) {
             fDstGpu->removeGpuTraceMarker(&newMarker);
         }
     }
     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);
     prevDrawState->unref();
     this->reset();
     ++fDrawID;
 }
 
 bool GrInOrderDrawBuffer::onCopySurface(GrSurface* dst,
                                         GrSurface* src,
@@ skipping 295 matching lines @@
     this->addToCmdBuffer(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
 
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }