Drawstate on stack

src/gpu/GrContext.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 "GrContext.h"
 
@@ skipping 42 matching lines @@
 #endif
 
 static const size_t DRAW_BUFFER_VBPOOL_BUFFER_SIZE = 1 << 15;
 static const int DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS = 4;
 
 static const size_t DRAW_BUFFER_IBPOOL_BUFFER_SIZE = 1 << 11;
 static const int DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS = 4;
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 
-// Glorified typedef to avoid including GrDrawState.h in GrContext.h
-class GrContext::AutoRestoreEffects : public GrDrawState::AutoRestoreEffects {};
-
 class GrContext::AutoCheckFlush {
 public:
     AutoCheckFlush(GrContext* context) : fContext(context) { SkASSERT(context); }
 
     ~AutoCheckFlush() {
         if (fContext->fFlushToReduceCacheSize) {
             fContext->flush();
         }
     }
 
@@ skipping 12 matching lines @@
 
     if (context->init(backend, backendContext)) {
         return context;
     } else {
         context->unref();
         return NULL;
     }
 }
 
 GrContext::GrContext(const Options& opts) : fOptions(opts) {
-    fDrawState = NULL;
     fGpu = NULL;
     fClip = NULL;
     fPathRendererChain = NULL;
     fSoftwarePathRenderer = NULL;
     fResourceCache2 = NULL;
     fFontCache = NULL;
     fDrawBuffer = NULL;
     fDrawBufferVBAllocPool = NULL;
     fDrawBufferIBAllocPool = NULL;
     fFlushToReduceCacheSize = false;
     fAARectRenderer = NULL;
     fOvalRenderer = NULL;
     fViewMatrix.reset();
     fMaxTextureSizeOverride = 1 << 20;
 }
 
 bool GrContext::init(GrBackend backend, GrBackendContext backendContext) {
     SkASSERT(NULL == fGpu);
 
     fGpu = GrGpu::Create(backend, backendContext, this);
     if (NULL == fGpu) {
         return false;
     }
     this->initCommon();
     return true;
 }
 
 void GrContext::initCommon() {
-    fDrawState = SkNEW(GrDrawState);
-
     fResourceCache2 = SkNEW(GrResourceCache2);
     fResourceCache2->setOverBudgetCallback(OverBudgetCB, this);
 
     fFontCache = SkNEW_ARGS(GrFontCache, (fGpu));
 
     fLayerCache.reset(SkNEW_ARGS(GrLayerCache, (this)));
 
     fAARectRenderer = SkNEW_ARGS(GrAARectRenderer, (fGpu));
     fOvalRenderer = SkNEW(GrOvalRenderer);
 
@@ skipping 18 matching lines @@
     SkDELETE(fDrawBuffer);
     SkDELETE(fDrawBufferVBAllocPool);
     SkDELETE(fDrawBufferIBAllocPool);
 
     fAARectRenderer->unref();
     fOvalRenderer->unref();
 
     fGpu->unref();
     SkSafeUnref(fPathRendererChain);
     SkSafeUnref(fSoftwarePathRenderer);
-    fDrawState->unref();
 }
 
 void GrContext::abandonContext() {
     // abandon first to so destructors
     // don't try to free the resources in the API.
     fResourceCache2->abandonAll();
 
     fGpu->contextAbandoned();
 
     // a path renderer may be holding onto resources that
@@ skipping 141 matching lines @@
     GrSurfaceDesc rtDesc = desc;
     rtDesc.fFlags =  rtDesc.fFlags |
                      kRenderTarget_GrSurfaceFlag |
                      kNoStencil_GrSurfaceFlag;
     rtDesc.fWidth  = GrNextPow2(desc.fWidth);
     rtDesc.fHeight = GrNextPow2(desc.fHeight);
 
     GrTexture* texture = fGpu->createTexture(rtDesc, NULL, 0);
 
     if (texture) {
-        GrDrawTarget::AutoStateRestore asr(fDrawBuffer, GrDrawTarget::kReset_ASRInit);
-        GrDrawState* drawState = fDrawBuffer->drawState();
-        drawState->setRenderTarget(texture->asRenderTarget());
+        GrDrawState drawState;
+        drawState.setRenderTarget(texture->asRenderTarget());
 
         // if filtering is not desired then we want to ensure all
         // texels in the resampled image are copies of texels from
         // the original.
         GrTextureParams params(SkShader::kClamp_TileMode,
                                filter ? GrTextureParams::kBilerp_FilterMode :
                                         GrTextureParams::kNone_FilterMode);
-        drawState->addColorTextureProcessor(clampedTexture, SkMatrix::I(), params);
+        drawState.addColorTextureProcessor(clampedTexture, SkMatrix::I(), params);
 
-        drawState->setGeometryProcessor(
+        drawState.setGeometryProcessor(
                 GrDefaultGeoProcFactory::CreateAndSetAttribs(
-                        drawState,
+                        &drawState,
                         GrDefaultGeoProcFactory::kPosition_GPType |
                         GrDefaultGeoProcFactory::kLocalCoord_GPType))->unref();
 
-        GrDrawTarget::AutoReleaseGeometry arg(fDrawBuffer, 4, 0);
+        GrDrawTarget::AutoReleaseGeometry arg(fDrawBuffer, 4, drawState.getVertexStride(),  0);
 
         if (arg.succeeded()) {
             SkPoint* verts = (SkPoint*) arg.vertices();
             verts[0].setIRectFan(0, 0, texture->width(), texture->height(), 2 * sizeof(SkPoint));
             verts[1].setIRectFan(0, 0, 1, 1, 2 * sizeof(SkPoint));
-            fDrawBuffer->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4);
+            fDrawBuffer->drawNonIndexed(&drawState, kTriangleFan_GrPrimitiveType, 0, 4);
         }
     } else {
         // TODO: Our CPU stretch doesn't filter. But we create separate
         // stretched textures when the texture params is either filtered or
         // not. Either implement filtered stretch blit on CPU or just create
         // one when FBO case fails.
 
         rtDesc.fFlags = kNone_GrSurfaceFlags;
         // no longer need to clamp at min RT size.
         rtDesc.fWidth  = GrNextPow2(desc.fWidth);
@@ skipping 193 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::clear(const SkIRect* rect,
                       const GrColor color,
                       bool canIgnoreRect,
                       GrRenderTarget* renderTarget) {
     ASSERT_OWNED_RESOURCE(renderTarget);
     SkASSERT(renderTarget);
 
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GR_CREATE_TRACE_MARKER_CONTEXT("GrContext::clear", this);
-    GrDrawTarget* target = this->prepareToDraw(NULL, &are, &acf);
+    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, &acf);
     if (NULL == target) {
         return;
     }
     target->clear(rect, color, canIgnoreRect, renderTarget);
 }
 
 void GrContext::drawPaint(const GrPaint& origPaint) {
     // set rect to be big enough to fill the space, but not super-huge, so we
     // don't overflow fixed-point implementations
     SkRect r;
@@ skipping 56 matching lines @@
     verts[8] = verts[0];
     verts[9] = verts[1];
 }
 
 static inline bool is_irect(const SkRect& r) {
   return SkScalarIsInt(r.fLeft)  && SkScalarIsInt(r.fTop) &&
          SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);
 }
 
 static bool apply_aa_to_rect(GrDrawTarget* target,
+                             GrDrawState* ds,
+                             SkRect* devBoundRect,
                              const SkRect& rect,
                              SkScalar strokeWidth,
-                             const SkMatrix& combinedMatrix,
-                             SkRect* devBoundRect) {
-    if (!target->getDrawState().canTweakAlphaForCoverage() &&
-        target->shouldDisableCoverageAAForBlend()) {
+                             const SkMatrix& combinedMatrix) {
+    if (!ds->canTweakAlphaForCoverage() && !ds->couldApplyCoverage(*target->caps())) {
 #ifdef SK_DEBUG
         //SkDebugf("Turning off AA to correctly apply blend.\n");
 #endif
         return false;
     }
-    const GrDrawState& drawState = target->getDrawState();
-    if (drawState.getRenderTarget()->isMultisampled()) {
+
+    if (ds->getRenderTarget()->isMultisampled()) {
         return false;
     }
 
 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
     if (strokeWidth >= 0) {
 #endif
         if (!combinedMatrix.preservesAxisAlignment()) {
             return false;
         }
 
@@ skipping 21 matching lines @@
 void GrContext::drawRect(const GrPaint& paint,
                          const SkRect& rect,
                          const GrStrokeInfo* strokeInfo) {
     if (strokeInfo && strokeInfo->isDashed()) {
         SkPath path;
         path.addRect(rect);
         this->drawPath(paint, path, *strokeInfo);
         return;
     }
 
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
+    GrDrawState drawState;
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRect", target);
     SkScalar width = NULL == strokeInfo ? -1 : strokeInfo->getStrokeRec().getWidth();
-    SkMatrix matrix = target->drawState()->getViewMatrix();
+    SkMatrix matrix = drawState.getViewMatrix();
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
     if (width < 0) {
         SkRect rtRect;
-        target->getDrawState().getRenderTarget()->getBoundsRect(&rtRect);
+        drawState.getRenderTarget()->getBoundsRect(&rtRect);
         SkRect clipSpaceRTRect = rtRect;
         bool checkClip = false;
         if (this->getClip()) {
             checkClip = true;
             clipSpaceRTRect.offset(SkIntToScalar(this->getClip()->fOrigin.fX),
                                    SkIntToScalar(this->getClip()->fOrigin.fY));
         }
         // Does the clip contain the entire RT?
         if (!checkClip || target->getClip()->fClipStack->quickContains(clipSpaceRTRect)) {
             SkMatrix invM;
@@ skipping 11 matching lines @@
                 GrColor clearColor;
                 if (paint.isOpaqueAndConstantColor(&clearColor)) {
                     target->clear(NULL, clearColor, true, fRenderTarget);
                     return;
                 }
             }
         }
     }
 
     SkRect devBoundRect;
-    bool needAA = paint.isAntiAlias() &&
-                  !target->getDrawState().getRenderTarget()->isMultisampled();
-    bool doAA = needAA && apply_aa_to_rect(target, rect, width, matrix, &devBoundRect);
+    bool needAA = paint.isAntiAlias() && !drawState.getRenderTarget()->isMultisampled();
+    bool doAA = needAA && apply_aa_to_rect(target, &drawState, &devBoundRect, rect, width, matrix);
 
     if (doAA) {
         GrDrawState::AutoViewMatrixRestore avmr;
-        if (!avmr.setIdentity(target->drawState())) {
+        if (!avmr.setIdentity(&drawState)) {
             return;
         }
+
         if (width >= 0) {
             const SkStrokeRec& strokeRec = strokeInfo->getStrokeRec();
-            fAARectRenderer->strokeAARect(target, rect, matrix, devBoundRect, strokeRec);
+            fAARectRenderer->strokeAARect(target,
+                                          &drawState,
+                                          rect,
+                                          matrix,
+                                          devBoundRect,
+                                          strokeRec);
         } else {
             // filled AA rect
-            fAARectRenderer->fillAARect(target,
-                                        rect, matrix, devBoundRect);
+            fAARectRenderer->fillAARect(target, &drawState, rect, matrix, devBoundRect);
         }
         return;
     }
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
 
         static const int worstCaseVertCount = 10;
-        target->drawState()->setDefaultVertexAttribs();
-        target->drawState()->setGeometryProcessor(GrDefaultGeoProcFactory::Create(false))->unref();
-        GrDrawTarget::AutoReleaseGeometry geo(target, worstCaseVertCount, 0);
+        drawState.setDefaultVertexAttribs();
+        drawState.setGeometryProcessor(GrDefaultGeoProcFactory::Create(false))->unref();
+        GrDrawTarget::AutoReleaseGeometry geo(target,
+                                              worstCaseVertCount,
+                                              drawState.getVertexStride(),
+                                              0);
 
         if (!geo.succeeded()) {
             SkDebugf("Failed to get space for vertices!\n");
             return;
         }
 
         GrPrimitiveType primType;
         int vertCount;
         SkPoint* vertex = geo.positions();
 
         if (width > 0) {
             vertCount = 10;
             primType = kTriangleStrip_GrPrimitiveType;
             setStrokeRectStrip(vertex, rect, width);
         } else {
             // hairline
             vertCount = 5;
             primType = kLineStrip_GrPrimitiveType;
             vertex[0].set(rect.fLeft, rect.fTop);
             vertex[1].set(rect.fRight, rect.fTop);
             vertex[2].set(rect.fRight, rect.fBottom);
             vertex[3].set(rect.fLeft, rect.fBottom);
             vertex[4].set(rect.fLeft, rect.fTop);
         }
 
-        target->drawNonIndexed(primType, 0, vertCount);
+        target->drawNonIndexed(&drawState, primType, 0, vertCount);
     } else {
         // filled BW rect
-        target->drawSimpleRect(rect);
+        target->drawSimpleRect(&drawState, rect);
     }
 }
 
 void GrContext::drawRectToRect(const GrPaint& paint,
                                const SkRect& dstRect,
                                const SkRect& localRect,
                                const SkMatrix* localMatrix) {
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
+    GrDrawState drawState;
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRectToRect", target);
 
-    target->drawRect(dstRect, &localRect, localMatrix);
+    target->drawRect(&drawState, dstRect, &localRect, localMatrix);
 }
 
 static void set_vertex_attributes(GrDrawState* drawState,
                                   const SkPoint* texCoords,
                                   const GrColor* colors,
                                   int* colorOffset,
                                   int* texOffset) {
     *texOffset = -1;
     *colorOffset = -1;
 
@@ skipping 15 matching lines @@
 }
 
 void GrContext::drawVertices(const GrPaint& paint,
                              GrPrimitiveType primitiveType,
                              int vertexCount,
                              const SkPoint positions[],
                              const SkPoint texCoords[],
                              const GrColor colors[],
                              const uint16_t indices[],
                              int indexCount) {
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
+    GrDrawState drawState;
     GrDrawTarget::AutoReleaseGeometry geo; // must be inside AutoCheckFlush scope
 
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
-    GrDrawState* drawState = target->drawState();
 
     GR_CREATE_TRACE_MARKER("GrContext::drawVertices", target);
 
     int colorOffset = -1, texOffset = -1;
-    set_vertex_attributes(drawState, texCoords, colors, &colorOffset, &texOffset);
+    set_vertex_attributes(&drawState, texCoords, colors, &colorOffset, &texOffset);
 
-    size_t VertexStride = drawState->getVertexStride();
-    if (!geo.set(target, vertexCount, indexCount)) {
+    size_t vertexStride = drawState.getVertexStride();
+    if (!geo.set(target, vertexCount, vertexStride, indexCount)) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
     void* curVertex = geo.vertices();
 
     for (int i = 0; i < vertexCount; ++i) {
         *((SkPoint*)curVertex) = positions[i];
 
         if (texOffset >= 0) {
             *(SkPoint*)((intptr_t)curVertex + texOffset) = texCoords[i];
         }
         if (colorOffset >= 0) {
             *(GrColor*)((intptr_t)curVertex + colorOffset) = colors[i];
         }
-        curVertex = (void*)((intptr_t)curVertex + VertexStride);
+        curVertex = (void*)((intptr_t)curVertex + vertexStride);
     }
 
     // we don't currently apply offscreen AA to this path. Need improved
     // management of GrDrawTarget's geometry to avoid copying points per-tile.
     if (indices) {
         uint16_t* curIndex = (uint16_t*)geo.indices();
         for (int i = 0; i < indexCount; ++i) {
             curIndex[i] = indices[i];
         }
-        target->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
+        target->drawIndexed(&drawState, primitiveType, 0, 0, vertexCount, indexCount);
     } else {
-        target->drawNonIndexed(primitiveType, 0, vertexCount);
+        target->drawNonIndexed(&drawState, primitiveType, 0, vertexCount);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawRRect(const GrPaint& paint,
                           const SkRRect& rrect,
                           const GrStrokeInfo& strokeInfo) {
     if (rrect.isEmpty()) {
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.addRRect(rrect);
         this->drawPath(paint, path, strokeInfo);
         return;
     }
 
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
+    GrDrawState drawState;
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRRect", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
-    if (!fOvalRenderer->drawRRect(target, this, paint.isAntiAlias(), rrect, strokeRec)) {
+    if (!fOvalRenderer->drawRRect(target, &drawState, this, paint.isAntiAlias(), rrect,
+                                  strokeRec)) {
         SkPath path;
         path.addRRect(rrect);
-        this->internalDrawPath(target, paint.isAntiAlias(), path, strokeInfo);
+        this->internalDrawPath(target, &drawState, paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawDRRect(const GrPaint& paint,
                            const SkRRect& outer,
                            const SkRRect& inner) {
     if (outer.isEmpty()) {
        return;
     }
 
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
+    GrDrawState drawState;
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
 
     GR_CREATE_TRACE_MARKER("GrContext::drawDRRect", target);
 
-    if (!fOvalRenderer->drawDRRect(target, this, paint.isAntiAlias(), outer, inner)) {
+    if (!fOvalRenderer->drawDRRect(target, &drawState, this, paint.isAntiAlias(), outer, inner)) {
         SkPath path;
         path.addRRect(inner);
         path.addRRect(outer);
         path.setFillType(SkPath::kEvenOdd_FillType);
 
         GrStrokeInfo fillRec(SkStrokeRec::kFill_InitStyle);
-        this->internalDrawPath(target, paint.isAntiAlias(), path, fillRec);
+        this->internalDrawPath(target, &drawState, paint.isAntiAlias(), path, fillRec);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawOval(const GrPaint& paint,
                          const SkRect& oval,
                          const GrStrokeInfo& strokeInfo) {
     if (oval.isEmpty()) {
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.addOval(oval);
         this->drawPath(paint, path, strokeInfo);
         return;
     }
 
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
+    GrDrawState drawState;
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawOval", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
 
-    if (!fOvalRenderer->drawOval(target, this, paint.isAntiAlias(), oval, strokeRec)) {
+    if (!fOvalRenderer->drawOval(target, &drawState, this, paint.isAntiAlias(), oval, strokeRec)) {
         SkPath path;
         path.addOval(oval);
-        this->internalDrawPath(target, paint.isAntiAlias(), path, strokeInfo);
+        this->internalDrawPath(target, &drawState, paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(GrDrawTarget* target,
+                            GrDrawState* drawState,
                             const SkPath& path,
                             const SkStrokeRec& stroke,
                             SkRect rects[2]) {
     SkASSERT(stroke.isFillStyle());
 
     if (path.isInverseFillType()) {
         return false;
     }
 
-    const GrDrawState& drawState = target->getDrawState();
-
     // TODO: this restriction could be lifted if we were willing to apply
     // the matrix to all the points individually rather than just to the rect
-    if (!drawState.getViewMatrix().preservesAxisAlignment()) {
+    if (!drawState->getViewMatrix().preservesAxisAlignment()) {
         return false;
     }
 
-    if (!target->getDrawState().canTweakAlphaForCoverage() &&
-        target->shouldDisableCoverageAAForBlend()) {
+    if (!drawState->canTweakAlphaForCoverage() && !drawState->couldApplyCoverage(*target->caps())) {
         return false;
     }
 
     SkPath::Direction dirs[2];
     if (!path.isNestedRects(rects, dirs)) {
         return false;
     }
 
     if (SkPath::kWinding_FillType == path.getFillType() && dirs[0] == dirs[1]) {
         // The two rects need to be wound opposite to each other
@@ skipping 28 matching lines @@
     if (path.isEmpty()) {
        if (path.isInverseFillType()) {
            this->drawPaint(paint);
        }
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPoint pts[2];
         if (path.isLine(pts)) {
-            AutoRestoreEffects are;
             AutoCheckFlush acf(this);
-            GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
+            GrDrawState drawState;
+            GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
             if (NULL == target) {
                 return;
-            }
-            GrDrawState* drawState = target->drawState();
+            };
 
-            SkMatrix origViewMatrix = drawState->getViewMatrix();
+            SkMatrix origViewMatrix = drawState.getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
-            if (avmr.setIdentity(target->drawState())) {
-                if (GrDashingEffect::DrawDashLine(pts, paint, strokeInfo, fGpu, target,
-                                                  origViewMatrix)) {
+            if (avmr.setIdentity(&drawState)) {
+                if (GrDashingEffect::DrawDashLine(fGpu, target, &drawState, pts, paint,
+                                                  strokeInfo, origViewMatrix)) {
                     return;
                 }
             }
         }
 
         // Filter dashed path into new path with the dashing applied
         const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
         SkTLazy<SkPath> effectPath;
         GrStrokeInfo newStrokeInfo(strokeInfo, false);
         SkStrokeRec* stroke = newStrokeInfo.getStrokeRecPtr();
         if (SkDashPath::FilterDashPath(effectPath.init(), path, stroke, NULL, info)) {
             this->drawPath(paint, *effectPath.get(), newStrokeInfo);
             return;
         }
 
         this->drawPath(paint, path, newStrokeInfo);
         return;
     }
 
     // Note that internalDrawPath may sw-rasterize the path into a scratch texture.
     // Scratch textures can be recycled after they are returned to the texture
     // cache. This presents a potential hazard for buffered drawing. However,
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
-    GrDrawTarget* target = this->prepareToDraw(&paint, &are, &acf);
+    GrDrawState drawState;
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
-    GrDrawState* drawState = target->drawState();
 
     GR_CREATE_TRACE_MARKER1("GrContext::drawPath", target, "Is Convex", path.isConvex());
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
-    bool useCoverageAA = paint.isAntiAlias() && !drawState->getRenderTarget()->isMultisampled();
+    bool useCoverageAA = paint.isAntiAlias() && !drawState.getRenderTarget()->isMultisampled();
 
     if (useCoverageAA && strokeRec.getWidth() < 0 && !path.isConvex()) {
         // Concave AA paths are expensive - try to avoid them for special cases
         SkRect rects[2];
 
-        if (is_nested_rects(target, path, strokeRec, rects)) {
-            SkMatrix origViewMatrix = drawState->getViewMatrix();
+        if (is_nested_rects(target, &drawState, path, strokeRec, rects)) {
+            SkMatrix origViewMatrix = drawState.getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
-            if (!avmr.setIdentity(target->drawState())) {
+            if (!avmr.setIdentity(&drawState)) {
                 return;
             }
 
-            fAARectRenderer->fillAANestedRects(target, rects, origViewMatrix);
+            fAARectRenderer->fillAANestedRects(target, &drawState, rects, origViewMatrix);
             return;
         }
     }
 
     SkRect ovalRect;
     bool isOval = path.isOval(&ovalRect);
 
     if (!isOval || path.isInverseFillType()
-        || !fOvalRenderer->drawOval(target, this, paint.isAntiAlias(), ovalRect, strokeRec)) {
-        this->internalDrawPath(target, paint.isAntiAlias(), path, strokeInfo);
+        || !fOvalRenderer->drawOval(target, &drawState, this, paint.isAntiAlias(), ovalRect,
+                                    strokeRec)) {
+        this->internalDrawPath(target, &drawState, paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
-void GrContext::internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path,
+void GrContext::internalDrawPath(GrDrawTarget* target,
+                                 GrDrawState* drawState,
+                                 bool useAA,
+                                 const SkPath& path,
                                  const GrStrokeInfo& strokeInfo) {
     SkASSERT(!path.isEmpty());
 
     GR_CREATE_TRACE_MARKER("GrContext::internalDrawPath", target);
 
 
     // An Assumption here is that path renderer would use some form of tweaking
     // the src color (either the input alpha or in the frag shader) to implement
     // aa. If we have some future driver-mojo path AA that can do the right
     // thing WRT to the blend then we'll need some query on the PR.
     bool useCoverageAA = useAA &&
-        !target->getDrawState().getRenderTarget()->isMultisampled() &&
-        !target->shouldDisableCoverageAAForBlend();
+        !drawState->getRenderTarget()->isMultisampled() &&
+        drawState->couldApplyCoverage(*target->caps());
 
 
     GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
-                           GrPathRendererChain::kColor_DrawType;
+                        GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
     SkTCopyOnFirstWrite<SkStrokeRec> stroke(strokeInfo.getStrokeRec());
 
     // Try a 1st time without stroking the path and without allowing the SW renderer
-    GrPathRenderer* pr = this->getPathRenderer(*pathPtr, *stroke, target, false, type);
+    GrPathRenderer* pr = this->getPathRenderer(target, drawState, *pathPtr, *stroke, false, type);
 
     if (NULL == pr) {
         if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*stroke, this->getMatrix(), NULL)) {
             // It didn't work the 1st time, so try again with the stroked path
             if (stroke->applyToPath(tmpPath.init(), *pathPtr)) {
                 pathPtr = tmpPath.get();
                 stroke.writable()->setFillStyle();
                 if (pathPtr->isEmpty()) {
                     return;
                 }
             }
         }
 
         // This time, allow SW renderer
-        pr = this->getPathRenderer(*pathPtr, *stroke, target, true, type);
+        pr = this->getPathRenderer(target, drawState, *pathPtr, *stroke, true, type);
     }
 
     if (NULL == pr) {
 #ifdef SK_DEBUG
         SkDebugf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
-    pr->drawPath(*pathPtr, *stroke, target, useCoverageAA);
+    pr->drawPath(target, drawState, *pathPtr, *stroke, useCoverageAA);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(int flagsBitfield) {
     if (NULL == fDrawBuffer) {
         return;
     }
 
     if (kDiscard_FlushBit & flagsBitfield) {
@@ skipping 115 matching lines @@
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
 
     // This function can be called in the midst of drawing another object (e.g., when uploading a
     // SW-rasterized clip while issuing a draw). So we push the current geometry state before
     // drawing a rect to the render target.
     // The bracket ensures we pop the stack if we wind up flushing below.
     {
         GrDrawTarget* drawTarget = this->prepareToDraw(NULL, NULL, NULL);
-        GrDrawTarget::AutoGeometryAndStatePush agasp(drawTarget, GrDrawTarget::kReset_ASRInit,
-                                                     &matrix);
-        GrDrawState* drawState = drawTarget->drawState();
-        drawState->addColorProcessor(fp);
-        drawState->setRenderTarget(renderTarget);
-        drawState->disableState(GrDrawState::kClip_StateBit);
-        drawTarget->drawSimpleRect(SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)));
+        GrDrawTarget::AutoGeometryPush agp(drawTarget);
+
+        GrDrawState drawState(matrix);
+        drawState.addColorProcessor(fp);
+        drawState.setRenderTarget(renderTarget);
+        drawTarget->drawSimpleRect(&drawState, SkRect::MakeWH(SkIntToScalar(width),
+                                                              SkIntToScalar(height)));
     }
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
         this->flushSurfaceWrites(surface);
     }
 
     return true;
 }
 
 // toggles between RGBA and BGRA
@@ skipping 93 matching lines @@
                     fp.reset(GrConfigConversionEffect::Create(
                             src, swapRAndB, GrConfigConversionEffect::kNone_PMConversion,
                             textureMatrix));
                 }
                 swapRAndB = false; // we will handle the swap in the draw.
 
                 // We protect the existing geometry here since it may not be
                 // clear to the caller that a draw operation (i.e., drawSimpleRect)
                 // can be invoked in this method
                 {
-                    GrDrawTarget::AutoGeometryAndStatePush agasp(fDrawBuffer,
-                                                                 GrDrawTarget::kReset_ASRInit);
-                    GrDrawState* drawState = fDrawBuffer->drawState();
+                    GrDrawTarget::AutoGeometryPush agp(fDrawBuffer);
+                    GrDrawState drawState;
                     SkASSERT(fp);
-                    drawState->addColorProcessor(fp);
+                    drawState.addColorProcessor(fp);
 
-                    drawState->setRenderTarget(tempTexture->asRenderTarget());
+                    drawState.setRenderTarget(tempTexture->asRenderTarget());
                     SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
-                    fDrawBuffer->drawSimpleRect(rect);
+                    fDrawBuffer->drawSimpleRect(&drawState, rect);
                     // we want to read back from the scratch's origin
                     left = 0;
                     top = 0;
                     target = tempTexture->asRenderTarget();
                 }
                 this->flushSurfaceWrites(target);
             }
         }
     }
 
@@ skipping 31 matching lines @@
     }
     GrRenderTarget* rt = surface->asRenderTarget();
     if (fGpu && rt) {
         fGpu->resolveRenderTarget(rt);
     }
 }
 
 void GrContext::discardRenderTarget(GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     ASSERT_OWNED_RESOURCE(renderTarget);
-    AutoRestoreEffects are;
     AutoCheckFlush acf(this);
-    GrDrawTarget* target = this->prepareToDraw(NULL, &are, &acf);
+    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, &acf);
     if (NULL == target) {
         return;
     }
     target->discard(renderTarget);
 }
 
 void GrContext::copySurface(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
                             const SkIPoint& dstPoint, uint32_t pixelOpsFlags) {
     if (NULL == src || NULL == dst) {
         return;
@@ skipping 14 matching lines @@
         this->flush();
     }
 }
 
 void GrContext::flushSurfaceWrites(GrSurface* surface) {
     if (surface->surfacePriv().hasPendingWrite()) {
         this->flush();
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-GrDrawTarget* GrContext::prepareToDraw(const GrPaint* paint,
-                                       AutoRestoreEffects* are,
-                                       AutoCheckFlush* acf) {
-    // All users of this draw state should be freeing up all effects when they're done.
-    // Otherwise effects that own resources may keep those resources alive indefinitely.
-    SkASSERT(0 == fDrawState->numColorStages() && 0 == fDrawState->numCoverageStages() &&
-             !fDrawState->hasGeometryProcessor());
-
+GrDrawTarget* GrContext::prepareToDraw(GrDrawState* ds,
+                                       const GrPaint* paint,
+                                       const AutoCheckFlush* acf) {
     if (NULL == fGpu) {
         return NULL;
     }
 
     ASSERT_OWNED_RESOURCE(fRenderTarget.get());
-    if (paint) {
-        SkASSERT(are);
-        SkASSERT(acf);
-        are->set(fDrawState);
-        fDrawState->setFromPaint(*paint, fViewMatrix, fRenderTarget.get());
+    if (ds) {
+        if (paint) {
+            SkASSERT(acf);
+            ds->setFromPaint(*paint, fViewMatrix, fRenderTarget.get());
 #if GR_DEBUG_PARTIAL_COVERAGE_CHECK
-        if ((paint->hasMask() || 0xff != paint->fCoverage) &&
-            !fDrawState->couldApplyCoverage(fGpu->caps())) {
-            SkDebugf("Partial pixel coverage will be incorrectly blended.\n");
+            if ((paint->hasMask() || 0xff != paint->fCoverage) &&
+                !fDrawState->couldApplyCoverage(fGpu->caps())) {
+                SkDebugf("Partial pixel coverage will be incorrectly blended.\n");
+            }
+#endif
+            // Clear any vertex attributes configured for the previous use of the
+            // GrDrawState which can effect which blend optimizations are in effect.
+            ds->setDefaultVertexAttribs();
+        } else {
+            ds->reset(fViewMatrix);
+            ds->setRenderTarget(fRenderTarget.get());
         }
-#endif
-        // Clear any vertex attributes configured for the previous use of the
-        // GrDrawState which can effect which blend optimizations are in effect.
-        fDrawState->setDefaultVertexAttribs();
-    } else {
-        fDrawState->reset(fViewMatrix);
-        fDrawState->setRenderTarget(fRenderTarget.get());
+        ds->setState(GrDrawState::kClip_StateBit, fClip && !fClip->fClipStack->isWideOpen());
     }
-    fDrawState->setState(GrDrawState::kClip_StateBit, fClip &&
-                                                     !fClip->fClipStack->isWideOpen());
     fDrawBuffer->setClip(fClip);
-    SkASSERT(fDrawState == fDrawBuffer->drawState());
     return fDrawBuffer;
 }
 
 /*
  * This method finds a path renderer that can draw the specified path on
  * the provided target.
  * Due to its expense, the software path renderer has split out so it can
  * can be individually allowed/disallowed via the "allowSW" boolean.
  */
-GrPathRenderer* GrContext::getPathRenderer(const SkPath& path,
+GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target,
+                                           const GrDrawState* drawState,
+                                           const SkPath& path,
                                            const SkStrokeRec& stroke,
-                                           const GrDrawTarget* target,
                                            bool allowSW,
                                            GrPathRendererChain::DrawType drawType,
                                            GrPathRendererChain::StencilSupport* stencilSupport) {
 
     if (NULL == fPathRendererChain) {
         fPathRendererChain = SkNEW_ARGS(GrPathRendererChain, (this));
     }
 
-    GrPathRenderer* pr = fPathRendererChain->getPathRenderer(path,
+    GrPathRenderer* pr = fPathRendererChain->getPathRenderer(target,
+                                                             drawState,
+                                                             path,
                                                              stroke,
-                                                             target,
                                                              drawType,
                                                              stencilSupport);
 
     if (NULL == pr && allowSW) {
         if (NULL == fSoftwarePathRenderer) {
             fSoftwarePathRenderer = SkNEW_ARGS(GrSoftwarePathRenderer, (this));
         }
         pr = fSoftwarePathRenderer;
     }
 
@@ skipping 32 matching lines @@
                                     DRAW_BUFFER_VBPOOL_BUFFER_SIZE,
                                     DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS));
     fDrawBufferIBAllocPool =
         SkNEW_ARGS(GrIndexBufferAllocPool, (fGpu, false,
                                    DRAW_BUFFER_IBPOOL_BUFFER_SIZE,
                                    DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS));
 
     fDrawBuffer = SkNEW_ARGS(GrInOrderDrawBuffer, (fGpu,
                                                    fDrawBufferVBAllocPool,
                                                    fDrawBufferIBAllocPool));
-
-    fDrawBuffer->setDrawState(fDrawState);
 }
 
 GrDrawTarget* GrContext::getTextTarget() {
     return this->prepareToDraw(NULL, NULL, NULL);
 }
 
 const GrIndexBuffer* GrContext::getQuadIndexBuffer() const {
     return fGpu->getQuadIndexBuffer();
 }
 
@@ skipping 67 matching lines @@
     fResourceCache2->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif