Drawstate on stack

src/gpu/GrDrawTarget.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
@@ skipping 75 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #define DEBUG_INVAL_BUFFER 0xdeadcafe
 #define DEBUG_INVAL_START_IDX -1
 
 GrDrawTarget::GrDrawTarget(GrContext* context)
     : fClip(NULL)
     , fContext(context)
     , fGpuTraceMarkerCount(0) {
     SkASSERT(context);
-    fDrawState = &fDefaultDrawState;
-    // We assume that fDrawState always owns a ref to the object it points at.
-    fDefaultDrawState.ref();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.push_back();
 #ifdef SK_DEBUG
     geoSrc.fVertexCount = DEBUG_INVAL_START_IDX;
     geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
     geoSrc.fIndexCount = DEBUG_INVAL_START_IDX;
     geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
 #endif
     geoSrc.fVertexSrc = kNone_GeometrySrcType;
     geoSrc.fIndexSrc  = kNone_GeometrySrcType;
 }
 
 GrDrawTarget::~GrDrawTarget() {
     SkASSERT(1 == fGeoSrcStateStack.count());
     SkDEBUGCODE(GeometrySrcState& geoSrc = fGeoSrcStateStack.back());
     SkASSERT(kNone_GeometrySrcType == geoSrc.fIndexSrc);
     SkASSERT(kNone_GeometrySrcType == geoSrc.fVertexSrc);
-    fDrawState->unref();
 }
 
 void GrDrawTarget::releaseGeometry() {
     int popCnt = fGeoSrcStateStack.count() - 1;
     while (popCnt) {
         this->popGeometrySource();
         --popCnt;
     }
     this->resetVertexSource();
     this->resetIndexSource();
 }
 
 void GrDrawTarget::setClip(const GrClipData* clip) {
     fClip = clip;
 }
 
 const GrClipData* GrDrawTarget::getClip() const {
     return fClip;
 }
 
-void GrDrawTarget::setDrawState(GrDrawState*  drawState) {
-    SkASSERT(fDrawState);
-    if (NULL == drawState) {
-        drawState = &fDefaultDrawState;
-    }
-    if (fDrawState != drawState) {
-        fDrawState->unref();
-        drawState->ref();
-        fDrawState = drawState;
-    }
-}
-
 bool GrDrawTarget::reserveVertexSpace(size_t vertexSize,
                                       int vertexCount,
                                       void** vertices) {
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     bool acquired = false;
     if (vertexCount > 0) {
         SkASSERT(vertices);
         this->releasePreviousVertexSource();
         geoSrc.fVertexSrc = kNone_GeometrySrcType;
 
@@ skipping 26 matching lines @@
         geoSrc.fIndexSrc = kReserved_GeometrySrcType;
         geoSrc.fIndexCount = indexCount;
     } else if (indices) {
         *indices = NULL;
     }
     return acquired;
 
 }
 
 bool GrDrawTarget::reserveVertexAndIndexSpace(int vertexCount,
+                                              size_t vertexStride,
                                               int indexCount,
                                               void** vertices,
                                               void** indices) {
-    size_t vertexStride = this->drawState()->getVertexStride();
-    this->willReserveVertexAndIndexSpace(vertexCount, indexCount);
+    this->willReserveVertexAndIndexSpace(vertexCount, vertexStride, indexCount);
     if (vertexCount) {
         if (!this->reserveVertexSpace(vertexStride, vertexCount, vertices)) {
             if (indexCount) {
                 this->resetIndexSource();
             }
             return false;
         }
     }
     if (indexCount) {
         if (!this->reserveIndexSpace(indexCount, indices)) {
             if (vertexCount) {
                 this->resetVertexSource();
             }
             return false;
         }
     }
     return true;
 }
 
-bool GrDrawTarget::geometryHints(int32_t* vertexCount,
+bool GrDrawTarget::geometryHints(size_t vertexStride,
+                                 int32_t* vertexCount,
                                  int32_t* indexCount) const {
     if (vertexCount) {
         *vertexCount = -1;
     }
     if (indexCount) {
         *indexCount = -1;
     }
     return false;
 }
 
@@ skipping 30 matching lines @@
 #ifdef SK_DEBUG
             geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
 #endif
             break;
         default:
             SkFAIL("Unknown Index Source Type.");
             break;
     }
 }
 
-void GrDrawTarget::setVertexSourceToBuffer(const GrVertexBuffer* buffer) {
+void GrDrawTarget::setVertexSourceToBuffer(const GrVertexBuffer* buffer, size_t vertexStride) {
     this->releasePreviousVertexSource();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     geoSrc.fVertexSrc    = kBuffer_GeometrySrcType;
     geoSrc.fVertexBuffer = buffer;
     buffer->ref();
-    geoSrc.fVertexSize = this->drawState()->getVertexStride();
+    geoSrc.fVertexSize = vertexStride;
 }
 
 void GrDrawTarget::setIndexSourceToBuffer(const GrIndexBuffer* buffer) {
     this->releasePreviousIndexSource();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     geoSrc.fIndexSrc     = kBuffer_GeometrySrcType;
     geoSrc.fIndexBuffer  = buffer;
     buffer->ref();
 }
 
@@ skipping 27 matching lines @@
     SkASSERT(fGeoSrcStateStack.count() > 1);
 
     this->geometrySourceWillPop(fGeoSrcStateStack.fromBack(1));
     this->releasePreviousVertexSource();
     this->releasePreviousIndexSource();
     fGeoSrcStateStack.pop_back();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-bool GrDrawTarget::checkDraw(GrPrimitiveType type, int startVertex,
-                             int startIndex, int vertexCount,
+bool GrDrawTarget::checkDraw(const GrDrawState& drawState,
+                             GrPrimitiveType type,
+                             int startVertex,
+                             int startIndex,
+                             int vertexCount,
                              int indexCount) const {
-    const GrDrawState& drawState = this->getDrawState();
 #ifdef SK_DEBUG
     const GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     int maxVertex = startVertex + vertexCount;
     int maxValidVertex;
     switch (geoSrc.fVertexSrc) {
         case kNone_GeometrySrcType:
             SkFAIL("Attempting to draw without vertex src.");
         case kReserved_GeometrySrcType: // fallthrough
             maxValidVertex = geoSrc.fVertexCount;
             break;
@@ skipping 51 matching lines @@
     }
 
     SkASSERT(drawState.validateVertexAttribs());
 #endif
     if (NULL == drawState.getRenderTarget()) {
         return false;
     }
     return true;
 }
 
-bool GrDrawTarget::setupDstReadIfNecessary(GrDeviceCoordTexture* dstCopy, const SkRect* drawBounds) {
-    if (this->caps()->dstReadInShaderSupport() || !this->getDrawState().willEffectReadDstColor()) {
+bool GrDrawTarget::setupDstReadIfNecessary(GrDrawState* ds,
+                                           GrDeviceCoordTexture* dstCopy,
+                                           const SkRect* drawBounds) {
+    if (this->caps()->dstReadInShaderSupport() || !ds->willEffectReadDstColor()) {
         return true;
     }
-    GrRenderTarget* rt = this->drawState()->getRenderTarget();
     SkIRect copyRect;
     const GrClipData* clip = this->getClip();
+    GrRenderTarget* rt = ds->getRenderTarget();
     clip->getConservativeBounds(rt, &copyRect);
 
     if (drawBounds) {
         SkIRect drawIBounds;
         drawBounds->roundOut(&drawIBounds);
         if (!copyRect.intersect(drawIBounds)) {
 #ifdef SK_DEBUG
             SkDebugf("Missed an early reject. Bailing on draw from setupDstReadIfNecessary.\n");
 #endif
             return false;
@@ skipping 21 matching lines @@
     SkIPoint dstPoint = {0, 0};
     if (this->copySurface(copy, rt, copyRect, dstPoint)) {
         dstCopy->setTexture(copy);
         dstCopy->setOffset(copyRect.fLeft, copyRect.fTop);
         return true;
     } else {
         return false;
     }
 }
 
-void GrDrawTarget::drawIndexed(GrPrimitiveType type,
+void GrDrawTarget::drawIndexed(GrDrawState* ds,
+                               GrPrimitiveType type,
                                int startVertex,
                                int startIndex,
                                int vertexCount,
                                int indexCount,
                                const SkRect* devBounds) {
-    if (indexCount > 0 && this->checkDraw(type, startVertex, startIndex, vertexCount, indexCount)) {
+    SkASSERT(ds);
+    if (indexCount > 0 &&
+        this->checkDraw(*ds, type, startVertex, startIndex, vertexCount, indexCount)) {
+
         // Setup clip
         GrClipMaskManager::ScissorState scissorState;
         GrDrawState::AutoRestoreEffects are;
         GrDrawState::AutoRestoreStencil ars;
-        if (!this->setupClip(devBounds, &are, &ars, &scissorState)) {
+        if (!this->setupClip(devBounds, &are, &ars, ds, &scissorState)) {
             return;
         }
 
         DrawInfo info;
         info.fPrimitiveType = type;
         info.fStartVertex   = startVertex;
         info.fStartIndex    = startIndex;
         info.fVertexCount   = vertexCount;
         info.fIndexCount    = indexCount;
 
         info.fInstanceCount         = 0;
         info.fVerticesPerInstance   = 0;
         info.fIndicesPerInstance    = 0;
 
         if (devBounds) {
             info.setDevBounds(*devBounds);
         }
         // TODO: We should continue with incorrect blending.
-        if (!this->setupDstReadIfNecessary(&info)) {
+        if (!this->setupDstReadIfNecessary(ds, &info)) {
             return;
         }
-        this->onDraw(info, scissorState);
+        this->onDraw(*ds, info, scissorState);
     }
 }
 
-void GrDrawTarget::drawNonIndexed(GrPrimitiveType type,
+void GrDrawTarget::drawNonIndexed(GrDrawState* ds,
+                                  GrPrimitiveType type,
                                   int startVertex,
                                   int vertexCount,
                                   const SkRect* devBounds) {
-    if (vertexCount > 0 && this->checkDraw(type, startVertex, -1, vertexCount, -1)) {
+    SkASSERT(ds);
+    if (vertexCount > 0 && this->checkDraw(*ds, type, startVertex, -1, vertexCount, -1)) {
+
         // Setup clip
         GrClipMaskManager::ScissorState scissorState;
         GrDrawState::AutoRestoreEffects are;
         GrDrawState::AutoRestoreStencil ars;
-        if (!this->setupClip(devBounds, &are, &ars, &scissorState)) {
+        if (!this->setupClip(devBounds, &are, &ars, ds, &scissorState)) {
             return;
         }
 
         DrawInfo info;
         info.fPrimitiveType = type;
         info.fStartVertex   = startVertex;
         info.fStartIndex    = 0;
         info.fVertexCount   = vertexCount;
         info.fIndexCount    = 0;
 
         info.fInstanceCount         = 0;
         info.fVerticesPerInstance   = 0;
         info.fIndicesPerInstance    = 0;
 
         if (devBounds) {
             info.setDevBounds(*devBounds);
         }
 
         // TODO: We should continue with incorrect blending.
-        if (!this->setupDstReadIfNecessary(&info)) {
+        if (!this->setupDstReadIfNecessary(ds, &info)) {
             return;
         }
-        this->onDraw(info, scissorState);
+        this->onDraw(*ds, info, scissorState);
     }
 }
 
 static const GrStencilSettings& winding_path_stencil_settings() {
     GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
         kIncClamp_StencilOp,
         kIncClamp_StencilOp,
         kAlwaysIfInClip_StencilFunc,
         0xFFFF, 0xFFFF, 0xFFFF);
     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
 }
 
 static const GrStencilSettings& even_odd_path_stencil_settings() {
     GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
         kInvert_StencilOp,
         kInvert_StencilOp,
         kAlwaysIfInClip_StencilFunc,
         0xFFFF, 0xFFFF, 0xFFFF);
     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
 }
 
 void GrDrawTarget::getPathStencilSettingsForFilltype(GrPathRendering::FillType fill,
+                                                     const GrStencilBuffer* sb,
                                                      GrStencilSettings* outStencilSettings) {
 
     switch (fill) {
         default:
             SkFAIL("Unexpected path fill.");
         case GrPathRendering::kWinding_FillType:
             *outStencilSettings = winding_path_stencil_settings();
             break;
         case GrPathRendering::kEvenOdd_FillType:
             *outStencilSettings = even_odd_path_stencil_settings();
             break;
     }
-    this->clipMaskManager()->adjustPathStencilParams(outStencilSettings);
+    this->clipMaskManager()->adjustPathStencilParams(sb, outStencilSettings);
 }
 
-void GrDrawTarget::stencilPath(const GrPath* path, GrPathRendering::FillType fill) {
+void GrDrawTarget::stencilPath(GrDrawState* ds,
+                               const GrPath* path,
+                               GrPathRendering::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path stenciling.
     SkASSERT(path);
     SkASSERT(this->caps()->pathRenderingSupport());
+    SkASSERT(ds);
 
     // Setup clip
     GrClipMaskManager::ScissorState scissorState;
     GrDrawState::AutoRestoreEffects are;
     GrDrawState::AutoRestoreStencil ars;
-    if (!this->setupClip(NULL, &are, &ars, &scissorState)) {
+    if (!this->setupClip(NULL, &are, &ars, ds, &scissorState)) {
         return;
     }
 
     // set stencil settings for path
     GrStencilSettings stencilSettings;
-    this->getPathStencilSettingsForFilltype(fill, &stencilSettings);
+    this->getPathStencilSettingsForFilltype(fill,
+                                            ds->getRenderTarget()->getStencilBuffer(),
+                                            &stencilSettings);
 
-    this->onStencilPath(path, scissorState, stencilSettings);
+    this->onStencilPath(*ds, path, scissorState, stencilSettings);
 }
 
-void GrDrawTarget::drawPath(const GrPath* path, GrPathRendering::FillType fill) {
+void GrDrawTarget::drawPath(GrDrawState* ds,
+                            const GrPath* path,
+                            GrPathRendering::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path rendering.
     SkASSERT(path);
     SkASSERT(this->caps()->pathRenderingSupport());
+    SkASSERT(ds);
 
     SkRect devBounds = path->getBounds();
-    SkMatrix viewM = this->drawState()->getViewMatrix();
+    SkMatrix viewM = ds->getViewMatrix();
     viewM.mapRect(&devBounds);
 
     // Setup clip
     GrClipMaskManager::ScissorState scissorState;
     GrDrawState::AutoRestoreEffects are;
     GrDrawState::AutoRestoreStencil ars;
-    if (!this->setupClip(&devBounds, &are, &ars, &scissorState)) {
+    if (!this->setupClip(&devBounds, &are, &ars, ds, &scissorState)) {
        return;
     }
 
     // set stencil settings for path
     GrStencilSettings stencilSettings;
-    this->getPathStencilSettingsForFilltype(fill, &stencilSettings);
+    this->getPathStencilSettingsForFilltype(fill,
+                                            ds->getRenderTarget()->getStencilBuffer(),
+                                            &stencilSettings);
 
     GrDeviceCoordTexture dstCopy;
-    if (!this->setupDstReadIfNecessary(&dstCopy, &devBounds)) {
+    if (!this->setupDstReadIfNecessary(ds, &dstCopy, &devBounds)) {
         return;
     }
 
-    this->onDrawPath(path, scissorState, stencilSettings, dstCopy.texture() ? &dstCopy : NULL);
+    this->onDrawPath(*ds, path, scissorState, stencilSettings, dstCopy.texture() ? &dstCopy : NULL);
 }
 
-void GrDrawTarget::drawPaths(const GrPathRange* pathRange,
-                             const uint32_t indices[], int count,
-                             const float transforms[], PathTransformType transformsType,
+void GrDrawTarget::drawPaths(GrDrawState* ds,
+                             const GrPathRange* pathRange,
+                             const uint32_t indices[],
+                             int count,
+                             const float transforms[],
+                             PathTransformType transformsType,
                              GrPathRendering::FillType fill) {
     SkASSERT(this->caps()->pathRenderingSupport());
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transforms);
+    SkASSERT(ds);
 
     // Setup clip
     GrClipMaskManager::ScissorState scissorState;
     GrDrawState::AutoRestoreEffects are;
     GrDrawState::AutoRestoreStencil ars;
 
-    if (!this->setupClip(NULL, &are, &ars, &scissorState)) {
+    if (!this->setupClip(NULL, &are, &ars, ds, &scissorState)) {
         return;
     }
 
     // set stencil settings for path
     GrStencilSettings stencilSettings;
-    this->getPathStencilSettingsForFilltype(fill, &stencilSettings);
+    this->getPathStencilSettingsForFilltype(fill,
+                                            ds->getRenderTarget()->getStencilBuffer(),
+                                            &stencilSettings);
 
     // Don't compute a bounding box for setupDstReadIfNecessary(), we'll opt
     // instead for it to just copy the entire dst. Realistically this is a moot
     // point, because any context that supports NV_path_rendering will also
     // support NV_blend_equation_advanced.
     GrDeviceCoordTexture dstCopy;
-    if (!this->setupDstReadIfNecessary(&dstCopy, NULL)) {
+    if (!this->setupDstReadIfNecessary(ds, &dstCopy, NULL)) {
         return;
     }
 
-    this->onDrawPaths(pathRange, indices, count, transforms, transformsType, scissorState,
+    this->onDrawPaths(*ds, pathRange, indices, count, transforms, transformsType, scissorState,
                       stencilSettings, dstCopy.texture() ? &dstCopy : NULL);
 }
 
-void GrDrawTarget::clear(const SkIRect* rect, GrColor color, bool canIgnoreRect,
+void GrDrawTarget::clear(const SkIRect* rect,
+                         GrColor color,
+                         bool canIgnoreRect,
                          GrRenderTarget* renderTarget) {
     if (fCaps->useDrawInsteadOfClear()) {
         // This works around a driver bug with clear by drawing a rect instead.
         // The driver will ignore a clear if it is the only thing rendered to a
         // target before the target is read.
         SkIRect rtRect = SkIRect::MakeWH(renderTarget->width(), renderTarget->height());
         if (NULL == rect || canIgnoreRect || rect->contains(rtRect)) {
             rect = &rtRect;
             // We first issue a discard() since that may help tilers.
             this->discard(renderTarget);
         }
-        AutoStateRestore asr(this, kReset_ASRInit, &SkMatrix::I());
 
-        this->drawState()->setColor(color);
-        this->drawState()->disableState(GrDrawState::kClip_StateBit);
-        this->drawState()->disableState(GrDrawState::kHWAntialias_StateBit);
-        this->drawState()->setRenderTarget(renderTarget);
+        GrDrawState drawState;
 
-        this->drawSimpleRect(*rect);
+        drawState.setColor(color);
+        drawState.setRenderTarget(renderTarget);
+
+        this->drawSimpleRect(&drawState, *rect);
     } else {       
         this->onClear(rect, color, canIgnoreRect, renderTarget);
     }
 }
 
 typedef GrTraceMarkerSet::Iter TMIter;
 void GrDrawTarget::saveActiveTraceMarkers() {
     if (this->caps()->gpuTracingSupport()) {
         SkASSERT(0 == fStoredTraceMarkers.count());
         fStoredTraceMarkers.addSet(fActiveTraceMarkers);
@@ skipping 26 matching lines @@
 void GrDrawTarget::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     if (this->caps()->gpuTracingSupport()) {
         SkASSERT(fGpuTraceMarkerCount >= 1);
         this->fActiveTraceMarkers.remove(*marker);
         --fGpuTraceMarkerCount;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void GrDrawTarget::drawIndexedInstances(GrPrimitiveType type,
+void GrDrawTarget::drawIndexedInstances(GrDrawState* ds,
+                                        GrPrimitiveType type,
                                         int instanceCount,
                                         int verticesPerInstance,
                                         int indicesPerInstance,
                                         const SkRect* devBounds) {
     if (!verticesPerInstance || !indicesPerInstance) {
         return;
     }
 
     int maxInstancesPerDraw = this->indexCountInCurrentSource() / indicesPerInstance;
     if (!maxInstancesPerDraw) {
         return;
     }
 
+    SkASSERT(ds);

[bsalomon, 2014/11/14 21:51:02]

move to top?

+
     // Setup clip
     GrClipMaskManager::ScissorState scissorState;
     GrDrawState::AutoRestoreEffects are;
     GrDrawState::AutoRestoreStencil ars;
-    if (!this->setupClip(devBounds, &are, &ars, &scissorState)) {
+    if (!this->setupClip(devBounds, &are, &ars, ds, &scissorState)) {
         return;
     }
 
     DrawInfo info;
     info.fPrimitiveType = type;
     info.fStartIndex = 0;
     info.fStartVertex = 0;
     info.fIndicesPerInstance = indicesPerInstance;
     info.fVerticesPerInstance = verticesPerInstance;
 
     // Set the same bounds for all the draws.
     if (devBounds) {
         info.setDevBounds(*devBounds);
     }
     // TODO: We should continue with incorrect blending.
-    if (!this->setupDstReadIfNecessary(&info)) {
+    if (!this->setupDstReadIfNecessary(ds, &info)) {
         return;
     }
-
     while (instanceCount) {
         info.fInstanceCount = SkTMin(instanceCount, maxInstancesPerDraw);
         info.fVertexCount = info.fInstanceCount * verticesPerInstance;
         info.fIndexCount = info.fInstanceCount * indicesPerInstance;
 
-        if (this->checkDraw(type,
+        if (this->checkDraw(*ds,
+                            type,
                             info.fStartVertex,
                             info.fStartIndex,
                             info.fVertexCount,
                             info.fIndexCount)) {
-            this->onDraw(info, scissorState);
+            this->onDraw(*ds, info, scissorState);
         }
         info.fStartVertex += info.fVertexCount;
         instanceCount -= info.fInstanceCount;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-GrDrawTarget::AutoStateRestore::AutoStateRestore() {
-    fDrawTarget = NULL;
-}
-
-GrDrawTarget::AutoStateRestore::AutoStateRestore(GrDrawTarget* target,
-                                                 ASRInit init,
-                                                 const SkMatrix* vm) {
-    fDrawTarget = NULL;
-    this->set(target, init, vm);
-}
-
-GrDrawTarget::AutoStateRestore::~AutoStateRestore() {
-    if (fDrawTarget) {
-        fDrawTarget->setDrawState(fSavedState);
-        fSavedState->unref();
-    }
-}
-
-void GrDrawTarget::AutoStateRestore::set(GrDrawTarget* target, ASRInit init, const SkMatrix* vm) {
-    SkASSERT(NULL == fDrawTarget);
-    fDrawTarget = target;
-    fSavedState = target->drawState();
-    SkASSERT(fSavedState);
-    fSavedState->ref();
-    if (kReset_ASRInit == init) {
-        if (NULL == vm) {
-            // calls the default cons
-            fTempState.init();
-        } else {
-            SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*vm));
-        }
-    } else {
-        SkASSERT(kPreserve_ASRInit == init);
-        if (NULL == vm) {
-            fTempState.set(*fSavedState);
-        } else {
-            SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*fSavedState, *vm));
-        }
-    }
-    target->setDrawState(fTempState.get());
-}
-
-bool GrDrawTarget::AutoStateRestore::setIdentity(GrDrawTarget* target, ASRInit init) {
-    SkASSERT(NULL == fDrawTarget);
-    fDrawTarget = target;
-    fSavedState = target->drawState();
-    SkASSERT(fSavedState);
-    fSavedState->ref();
-    if (kReset_ASRInit == init) {
-        // calls the default cons
-        fTempState.init();
-    } else {
-        SkASSERT(kPreserve_ASRInit == init);
-        // calls the copy cons
-        fTempState.set(*fSavedState);
-        if (!fTempState.get()->setIdentityViewMatrix()) {
-            // let go of any resources held by the temp
-            fTempState.get()->reset();
-            fDrawTarget = NULL;
-            fSavedState->unref();
-            fSavedState = NULL;
-            return false;
-        }
-    }
-    target->setDrawState(fTempState.get());
-    return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 GrDrawTarget::AutoReleaseGeometry::AutoReleaseGeometry(
                                          GrDrawTarget*  target,
                                          int vertexCount,
+                                         size_t vertexStride,
                                          int indexCount) {
     fTarget = NULL;
-    this->set(target, vertexCount, indexCount);
+    this->set(target, vertexCount, vertexStride, indexCount);
 }
 
 GrDrawTarget::AutoReleaseGeometry::AutoReleaseGeometry() {
     fTarget = NULL;
 }
 
 GrDrawTarget::AutoReleaseGeometry::~AutoReleaseGeometry() {
     this->reset();
 }
 
 bool GrDrawTarget::AutoReleaseGeometry::set(GrDrawTarget*  target,
                                             int vertexCount,
+                                            size_t vertexStride,
                                             int indexCount) {
     this->reset();
     fTarget = target;
     bool success = true;
     if (fTarget) {
         success = target->reserveVertexAndIndexSpace(vertexCount,
+                                                     vertexStride,
                                                      indexCount,
                                                      &fVertices,
                                                      &fIndices);
         if (!success) {
             fTarget = NULL;
             this->reset();
         }
     }
     SkASSERT(success == SkToBool(fTarget));
     return success;
@@ skipping 95 matching lines @@
         return true;
     }
 
     if (!GrDrawTarget::canCopySurface(dst, src, clippedSrcRect, clippedDstPoint)) {
         return false;
     }
 
     GrRenderTarget* rt = dst->asRenderTarget();
     GrTexture* tex = src->asTexture();
 
-    GrDrawTarget::AutoStateRestore asr(this, kReset_ASRInit);
-    this->drawState()->setRenderTarget(rt);
+    GrDrawState drawState;
+    drawState.setRenderTarget(rt);
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(clippedSrcRect.fLeft - clippedDstPoint.fX),
                         SkIntToScalar(clippedSrcRect.fTop - clippedDstPoint.fY));
     matrix.postIDiv(tex->width(), tex->height());
-    this->drawState()->addColorTextureProcessor(tex, matrix);
+    drawState.addColorTextureProcessor(tex, matrix);
     SkIRect dstRect = SkIRect::MakeXYWH(clippedDstPoint.fX,
                                         clippedDstPoint.fY,
                                         clippedSrcRect.width(),
                                         clippedSrcRect.height());
-    this->drawSimpleRect(dstRect);
+    this->drawSimpleRect(&drawState, dstRect);
     return true;
 }
 
-bool GrDrawTarget::canCopySurface(GrSurface* dst,
-                                  GrSurface* src,
+bool GrDrawTarget::canCopySurface(const GrSurface* dst,
+                                  const GrSurface* src,
                                   const SkIRect& srcRect,
                                   const SkIPoint& dstPoint) {
     SkASSERT(dst);
     SkASSERT(src);
 
     SkIRect clippedSrcRect;
     SkIPoint clippedDstPoint;
     // If the rect is outside the src or dst then we're guaranteed success
     if (!clip_srcrect_and_dstpoint(dst,
                                    src,
@@ skipping 184 matching lines @@
         id = static_cast<uint32_t>(sk_atomic_inc(&gUniqueID) + 1);
     } while (id == SK_InvalidUniqueID);
     return id;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 bool GrClipTarget::setupClip(const SkRect* devBounds,
                              GrDrawState::AutoRestoreEffects* are,
                              GrDrawState::AutoRestoreStencil* ars,
+                             GrDrawState* ds,
                              GrClipMaskManager::ScissorState* scissorState) {
-    return fClipMaskManager.setupClipping(this->getClip(),
-                                          devBounds,
+    return fClipMaskManager.setupClipping(ds,
                                           are,
                                           ars,
-                                          scissorState);
+                                          scissorState,
+                                          this->getClip(),
+                                          devBounds);
 }