Remove deferred version of GrDrawState.

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 559 matching lines @@
 
     GrAutoTRestore<bool> flushRestore(&fFlushing);
     fFlushing = true;
 
     fVertexPool.unmap();
     fIndexPool.unmap();
 
     GrDrawTarget::AutoClipRestore acr(fDstGpu);
     AutoGeometryAndStatePush agasp(fDstGpu, kPreserve_ASRInit);
 
-    GrDrawState playbackState;
-    GrDrawState* prevDrawState = fDstGpu->drawState();
-    prevDrawState->ref();
-    fDstGpu->setDrawState(&playbackState);
+    GrDrawState* prevDrawState = SkRef(fDstGpu->drawState());
 
     GrClipData clipData;
 
     StateAllocator::Iter stateIter(&fStates);
     ClipAllocator::Iter clipIter(&fClips);
     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: {
+                SkASSERT(fDstGpu->drawState() != prevDrawState);
                 SkAssertResult(drawIter.next());
                 fDstGpu->setVertexSourceToBuffer(drawIter->fVertexBuffer);
                 if (drawIter->isIndexed()) {
                     fDstGpu->setIndexSourceToBuffer(drawIter->fIndexBuffer);
                 }
                 fDstGpu->executeDraw(*drawIter);
                 break;
             }
             case kStencilPath_Cmd: {
+                SkASSERT(fDstGpu->drawState() != prevDrawState);
                 SkAssertResult(stencilPathIter.next());
                 fDstGpu->stencilPath(stencilPathIter->fPath.get(), stencilPathIter->fFill);
                 break;
             }
             case kDrawPath_Cmd: {
+                SkASSERT(fDstGpu->drawState() != prevDrawState);
                 SkAssertResult(drawPathIter.next());
                 fDstGpu->executeDrawPath(drawPathIter->fPath.get(), drawPathIter->fFill,
                                          NULL != drawPathIter->fDstCopy.texture() ?
                                             &drawPathIter->fDstCopy :
                                             NULL);
                 break;
             }
             case kDrawPaths_Cmd: {
+                SkASSERT(fDstGpu->drawState() != prevDrawState);
                 SkAssertResult(drawPathsIter.next());
                 const GrDeviceCoordTexture* dstCopy =
                     NULL !=drawPathsIter->fDstCopy.texture() ? &drawPathsIter->fDstCopy : NULL;
                 fDstGpu->executeDrawPaths(drawPathsIter->fPathCount, drawPathsIter->fPaths,
                                           drawPathsIter->fTransforms, drawPathsIter->fFill,
                                           drawPathsIter->fStroke, dstCopy);
                 break;
             }
             case kSetState_Cmd:
                 SkAssertResult(stateIter.next());
-                stateIter->restoreTo(&playbackState);
+                fDstGpu->setDrawState(stateIter.get());
                 break;
             case kSetClip_Cmd:
                 SkAssertResult(clipIter.next());
                 clipData.fClipStack = &clipIter->fStack;
                 clipData.fOrigin = clipIter->fOrigin;
                 fDstGpu->setClip(&clipData);
                 break;
             case kClear_Cmd:
                 SkAssertResult(clearIter.next());
                 if (GrColor_ILLEGAL == clearIter->fColor) {
@@ skipping 261 matching lines @@
         poolState.fUsedPoolVertexBytes = restoredState.fVertexSize * restoredState.fVertexCount;
     }
     if (kReserved_GeometrySrcType == restoredState.fIndexSrc ||
         kArray_GeometrySrcType == restoredState.fIndexSrc) {
         poolState.fUsedPoolIndexBytes = sizeof(uint16_t) *
                                          restoredState.fIndexCount;
     }
 }
 
 bool GrInOrderDrawBuffer::needsNewState() const {
-    return fStates.empty() || !fStates.back().isEqual(this->getDrawState());
+    return fStates.empty() || fStates.back() != this->getDrawState();
 }
 
 bool GrInOrderDrawBuffer::needsNewClip() const {
     if (this->getDrawState().isClipState()) {
        if (fClipSet &&
            (fClips.empty() ||
             fClips.back().fStack != *this->getClip()->fClipStack ||
             fClips.back().fOrigin != this->getClip()->fOrigin)) {
            return true;
        }
@@ skipping 13 matching lines @@
 }
 
 void GrInOrderDrawBuffer::recordClip() {
     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());
+    fStates.push_back() = this->getDrawState();
     this->addToCmdBuffer(kSetState_Cmd);
 }
 
 GrInOrderDrawBuffer::DrawRecord* GrInOrderDrawBuffer::recordDraw(const DrawInfo& info) {
     this->addToCmdBuffer(kDraw_Cmd);
     return &fDraws.push_back(info);
 }
 
 GrInOrderDrawBuffer::StencilPath* GrInOrderDrawBuffer::recordStencilPath() {
     this->addToCmdBuffer(kStencilPath_Cmd);
@@ skipping 18 matching lines @@
 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;
 }