Combine clip stack and clip origin into one struct in GrIODB.

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 530 matching lines @@
     fCmds.reset();
     fDraws.reset();
     fStencilPaths.reset();
     fDrawPath.reset();
     fDrawPaths.reset();
     fStates.reset();
     fClears.reset();
     fVertexPool.reset();
     fIndexPool.reset();
     fClips.reset();
-    fClipOrigins.reset();
     fCopySurfaces.reset();
     fGpuCmdMarkers.reset();
     fClipSet = true;
 }
 
 void GrInOrderDrawBuffer::flush() {
     if (fFlushing) {
         return;
     }
 
@@ skipping 18 matching lines @@
 
     GrDrawState playbackState;
     GrDrawState* prevDrawState = fDstGpu->drawState();
     prevDrawState->ref();
     fDstGpu->setDrawState(&playbackState);
 
     GrClipData clipData;
 
     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();
@@ skipping 36 matching lines @@
                                           drawPathsIter->fTransforms, drawPathsIter->fFill,
                                           drawPathsIter->fStroke, dstCopy);
                 break;
             }
             case kSetState_Cmd:
                 SkAssertResult(stateIter.next());
                 stateIter->restoreTo(&playbackState);
                 break;
             case kSetClip_Cmd:
                 SkAssertResult(clipIter.next());
-                SkAssertResult(clipOriginIter.next());
-                clipData.fClipStack = clipIter.get();
-                clipData.fOrigin = *clipOriginIter;
+                clipData.fClipStack = &clipIter->fStack;
+                clipData.fOrigin = clipIter->fOrigin;
                 fDstGpu->setClip(&clipData);
                 break;
             case kClear_Cmd:
                 SkAssertResult(clearIter.next());
                 if (GrColor_ILLEGAL == clearIter->fColor) {
                     fDstGpu->discard(clearIter->fRenderTarget);
                 } else {
                     fDstGpu->clear(&clearIter->fRect,
                                    clearIter->fColor,
                                    clearIter->fCanIgnoreRect,
                                    clearIter->fRenderTarget);
                 }
                 break;
             case kCopySurface_Cmd:
                 SkAssertResult(copySurfaceIter.next());
                 fDstGpu->copySurface(copySurfaceIter->fDst.get(),
                                      copySurfaceIter->fSrc.get(),
                                      copySurfaceIter->fSrcRect,
                                      copySurfaceIter->fDstPoint);
                 break;
         }
         if (cmd_has_trace_marker(fCmds[c])) {
             fDstGpu->removeGpuTraceMarker(&newMarker);
         }
     }
     fDstGpu->restoreActiveTraceMarkers();
     // we should have consumed all the states, clips, etc.
     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);
@@ skipping 231 matching lines @@
         poolState.fUsedPoolIndexBytes = sizeof(uint16_t) *
                                          restoredState.fIndexCount;
     }
 }
 
 bool GrInOrderDrawBuffer::needsNewState() const {
     return fStates.empty() || !fStates.back().isEqual(this->getDrawState());
 }
 
 bool GrInOrderDrawBuffer::needsNewClip() const {
-    SkASSERT(fClips.count() == fClipOrigins.count());
     if (this->getDrawState().isClipState()) {
        if (fClipSet &&
            (fClips.empty() ||
-            fClips.back() != *this->getClip()->fClipStack ||
-            fClipOrigins.back() != this->getClip()->fOrigin)) {
+            fClips.back().fStack != *this->getClip()->fClipStack ||
+            fClips.back().fOrigin != this->getClip()->fOrigin)) {
            return true;
        }
     }
     return false;
 }
 
 void GrInOrderDrawBuffer::addToCmdBuffer(uint8_t cmd) {
     SkASSERT(!cmd_has_trace_marker(cmd));
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         fCmds.push_back(add_trace_bit(cmd));
         fGpuCmdMarkers.push_back(activeTraceMarkers);
     } else {
         fCmds.push_back(cmd);
     }
 }
 
 void GrInOrderDrawBuffer::recordClip() {
-    fClips.push_back(*this->getClip()->fClipStack);
-    fClipOrigins.push_back() = this->getClip()->fOrigin;
+    fClips.push_back().fStack = *this->getClip()->fClipStack;
+    fClips.back().fOrigin = this->getClip()->fOrigin;
     fClipSet = false;
     this->addToCmdBuffer(kSetClip_Cmd);
 }
 
 void GrInOrderDrawBuffer::recordState() {
     fStates.push_back().saveFrom(this->getDrawState());
     this->addToCmdBuffer(kSetState_Cmd);
 }
 
 GrInOrderDrawBuffer::DrawRecord* GrInOrderDrawBuffer::recordDraw(const DrawInfo& info) {
@@ skipping 19 matching lines @@
 GrInOrderDrawBuffer::Clear* GrInOrderDrawBuffer::recordClear() {
     this->addToCmdBuffer(kClear_Cmd);
     return &fClears.push_back();
 }
 
 GrInOrderDrawBuffer::CopySurface* GrInOrderDrawBuffer::recordCopySurface() {
     this->addToCmdBuffer(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
-
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }