Remove coordchanges from drawstate

BUG=skia:

Review URL: https://codereview.chromium.org/818233002

18 files changed, 247 insertions, 238 deletions

diff --git a/src/gpu/GrAAConvexPathRenderer.cpp b/src/gpu/GrAAConvexPathRenderer.cpp
index 6d69823caf..3a344ce0b8 100644
--- a/src/gpu/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/GrAAConvexPathRenderer.cpp
@@ -505,8 +505,8 @@ static void create_vertices(const SegmentArray&  segments,
 class QuadEdgeEffect : public GrGeometryProcessor {
 public:
 
-    static GrGeometryProcessor* Create(GrColor color) {
-        return SkNEW_ARGS(QuadEdgeEffect, (color));
+    static GrGeometryProcessor* Create(GrColor color, const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(QuadEdgeEffect, (color, localMatrix));
     }
 
     virtual ~QuadEdgeEffect() {}
@@ -626,7 +626,8 @@ public:
     }
 
 private:
-    QuadEdgeEffect(GrColor color) : INHERITED(color) {
+    QuadEdgeEffect(GrColor color, const SkMatrix& localMatrix)
+        : INHERITED(color, false, localMatrix) {
         this->initClassID<QuadEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInQuadEdge = &this->addVertexAttrib(GrAttribute("inQuadEdge", kVec4f_GrVertexAttribType));
@@ -661,7 +662,9 @@ GrGeometryProcessor* QuadEdgeEffect::TestCreate(SkRandom* random,
                                                 const GrDrawTargetCaps& caps,
                                                 GrTexture*[]) {
     // Doesn't work without derivative instructions.
-    return caps.shaderDerivativeSupport() ? QuadEdgeEffect::Create(GrRandomColor(random)) : NULL;
+    return caps.shaderDerivativeSupport() ?
+           QuadEdgeEffect::Create(GrRandomColor(random),
+                                  GrProcessorUnitTest::TestMatrix(random)) : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -688,11 +691,13 @@ bool GrAAConvexPathRenderer::onDrawPath(GrDrawTarget* target,
     }
 
     SkMatrix viewMatrix = drawState->getViewMatrix();
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    SkMatrix invert;
+    if (!viewMatrix.invert(&invert)) {
         return false;
     }
 
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     // We use the fact that SkPath::transform path does subdivision based on
     // perspective. Otherwise, we apply the view matrix when copying to the
     // segment representation.
@@ -725,7 +730,7 @@ bool GrAAConvexPathRenderer::onDrawPath(GrDrawTarget* target,
     // Our computed verts should all be within one pixel of the segment control points.
     devBounds.outset(SK_Scalar1, SK_Scalar1);
 
-    SkAutoTUnref<GrGeometryProcessor> quadProcessor(QuadEdgeEffect::Create(color));
+    SkAutoTUnref<GrGeometryProcessor> quadProcessor(QuadEdgeEffect::Create(color, invert));
 
     GrDrawTarget::AutoReleaseGeometry arg(target, vCount, quadProcessor->getVertexStride(), iCount);
     SkASSERT(quadProcessor->getVertexStride() == sizeof(QuadVertex));
diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp
index 98e69657b3..319228e146 100644
--- a/src/gpu/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/GrAAHairLinePathRenderer.cpp
@@ -832,18 +832,30 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target,
     lineCnt = lines.count() / 2;
     conicCnt = conics.count() / 3;
 
+    // createGeom transforms the geometry to device space when the matrix does not have
+    // perspective.
+    GrDrawState::AutoViewMatrixRestore avmr;
+    SkMatrix invert = SkMatrix::I();
+    if (!drawState->getViewMatrix().hasPerspective()) {
+        avmr.setIdentity(drawState);
+        if (!drawState->getViewMatrix().invert(&invert)) {
+            return false;
+        }
+    }
+
     // do lines first
     if (lineCnt) {
         GrDrawTarget::AutoReleaseGeometry arg;
         SkRect devBounds;
 
+        GrDrawState::AutoRestoreEffects are(drawState);
         uint32_t gpFlags = GrDefaultGeoProcFactory::kPosition_GPType |
                            GrDefaultGeoProcFactory::kCoverage_GPType;
-        GrDrawState::AutoRestoreEffects are(drawState);
         SkAutoTUnref<const GrGeometryProcessor> gp(GrDefaultGeoProcFactory::Create(color,
                                                                                    gpFlags,
                                                                                    false,
-                                                                                   newCoverage));
+                                                                                   newCoverage,
+                                                                                   invert));
 
         if (!this->createLineGeom(target,
                                   drawState,
@@ -857,13 +869,6 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target,
             return false;
         }
 
-        // createLineGeom transforms the geometry to device space when the matrix does not have
-        // perspective.
-        GrDrawState::AutoViewMatrixRestore avmr;
-        if (!drawState->getViewMatrix().hasPerspective() && !avmr.setIdentity(drawState)) {
-            return false;
-        }
-
         // Check devBounds
         SkASSERT(check_bounds<LineVertex>(drawState, devBounds, arg.vertices(),
                                           kLineSegNumVertices * lineCnt));
@@ -906,14 +911,6 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target,
             return false;
         }
 
-        // createGeom transforms the geometry to device space when the matrix does not have
-        // perspective.
-        GrDrawState::AutoViewMatrixRestore avmr;
-        if (!drawState->getViewMatrix().hasPerspective() && !avmr.setIdentity(drawState)) {
-            return false;
-        }
-
-
         // Check devBounds
         SkASSERT(check_bounds<BezierVertex>(drawState, devBounds, arg.vertices(),
                                             kQuadNumVertices * quadCnt + kQuadNumVertices * conicCnt));
@@ -923,6 +920,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target,
                     GrQuadEffect::Create(color,
                                          kHairlineAA_GrProcessorEdgeType,
                                          *target->caps(),
+                                         invert,
                                          newCoverage));
             SkASSERT(hairQuadProcessor);
             GrDrawState::AutoRestoreEffects are(drawState);
@@ -946,7 +944,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(GrDrawTarget* target,
         if (conicCnt > 0) {
             SkAutoTUnref<GrGeometryProcessor> hairConicProcessor(
                     GrConicEffect::Create(color, kHairlineAA_GrProcessorEdgeType, *target->caps(),
-                                          newCoverage));
+                                          invert, newCoverage));
             SkASSERT(hairConicProcessor);
             GrDrawState::AutoRestoreEffects are(drawState);
             target->setIndexSourceToBuffer(fQuadsIndexBuffer);
diff --git a/src/gpu/GrAARectRenderer.cpp b/src/gpu/GrAARectRenderer.cpp
index 07e81ecef7..3f0e1b0117 100644
--- a/src/gpu/GrAARectRenderer.cpp
+++ b/src/gpu/GrAARectRenderer.cpp
@@ -26,16 +26,18 @@ enum CoverageAttribType {
 }
 
 static const GrGeometryProcessor* create_rect_gp(const GrDrawState& drawState, GrColor color,
-                                                 CoverageAttribType* type) {
+                                                 CoverageAttribType* type,
+                                                 const SkMatrix& localMatrix) {
     uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType;
     const GrGeometryProcessor* gp;
     if (drawState.canTweakAlphaForCoverage()) {
-        gp = GrDefaultGeoProcFactory::Create(color, flags);
+        gp = GrDefaultGeoProcFactory::Create(color, flags, localMatrix);
         SkASSERT(gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
         *type = kUseColor_CoverageAttribType;
     } else {
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
-        gp = GrDefaultGeoProcFactory::Create(color, flags, GrColorIsOpaque(color));
+        gp = GrDefaultGeoProcFactory::Create(color, flags, GrColorIsOpaque(color), 0xff,
+                                             localMatrix);
         SkASSERT(gp->getVertexStride()==sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         *type = kUseCoverage_CoverageAttribType;
     }
@@ -178,13 +180,15 @@ GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(bool miterStroke) {
 void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target,
                                           GrDrawState* drawState,
                                           GrColor color,
+                                          const SkMatrix& localMatrix,
                                           const SkRect& rect,
                                           const SkMatrix& combinedMatrix,
                                           const SkRect& devRect) {
     GrDrawState::AutoRestoreEffects are(drawState);
 
     CoverageAttribType type;
-    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type));
+    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type,
+                                                              localMatrix));
 
     size_t vertexStride = gp->getVertexStride();
     GrDrawTarget::AutoReleaseGeometry geo(target, 8, vertexStride, 0);
@@ -308,6 +312,7 @@ void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target,
 void GrAARectRenderer::strokeAARect(GrDrawTarget* target,
                                     GrDrawState* drawState,
                                     GrColor color,
+                                    const SkMatrix& localMatrix,
                                     const SkRect& rect,
                                     const SkMatrix& combinedMatrix,
                                     const SkRect& devRect,
@@ -354,7 +359,8 @@ void GrAARectRenderer::strokeAARect(GrDrawTarget* target,
     }
 
     if (spare <= 0 && miterStroke) {
-        this->fillAARect(target, drawState, color, devOutside, SkMatrix::I(), devOutside);
+        this->fillAARect(target, drawState, color, localMatrix, devOutside, SkMatrix::I(),
+                         devOutside);
         return;
     }
 
@@ -371,13 +377,14 @@ void GrAARectRenderer::strokeAARect(GrDrawTarget* target,
         devOutsideAssist.outset(0, ry);
     }
 
-    this->geometryStrokeAARect(target, drawState, color, devOutside, devOutsideAssist, devInside,
-                               miterStroke);
+    this->geometryStrokeAARect(target, drawState, color, localMatrix, devOutside, devOutsideAssist,
+                               devInside, miterStroke);
 }
 
 void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
                                             GrDrawState* drawState,
                                             GrColor color,
+                                            const SkMatrix& localMatrix,
                                             const SkRect& devOutside,
                                             const SkRect& devOutsideAssist,
                                             const SkRect& devInside,
@@ -385,7 +392,8 @@ void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
     GrDrawState::AutoRestoreEffects are(drawState);
 
     CoverageAttribType type;
-    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type));
+    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type,
+                                                              localMatrix));
 
     int innerVertexNum = 4;
     int outerVertexNum = miterStroke ? 4 : 8;
@@ -510,6 +518,7 @@ void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
 void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target,
                                          GrDrawState* drawState,
                                          GrColor color,
+                                         const SkMatrix& localMatrix,
                                          const SkRect rects[2],
                                          const SkMatrix& combinedMatrix) {
     SkASSERT(combinedMatrix.rectStaysRect());
@@ -521,10 +530,11 @@ void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target,
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
-        this->fillAARect(target, drawState, color, devOutside, SkMatrix::I(), devOutside);
+        this->fillAARect(target, drawState, color, localMatrix, devOutside, SkMatrix::I(),
+                         devOutside);
         return;
     }
 
-    this->geometryStrokeAARect(target, drawState, color, devOutside, devOutsideAssist, devInside,
-                               true);
+    this->geometryStrokeAARect(target, drawState, color, localMatrix, devOutside, devOutsideAssist,
+                               devInside, true);
 }
diff --git a/src/gpu/GrAARectRenderer.h b/src/gpu/GrAARectRenderer.h
index b1780ad46a..d97a111824 100644
--- a/src/gpu/GrAARectRenderer.h
+++ b/src/gpu/GrAARectRenderer.h
@@ -45,15 +45,17 @@ public:
     void fillAARect(GrDrawTarget* target,
                     GrDrawState* ds,
                     GrColor color,
+                    const SkMatrix& localMatrix,
                     const SkRect& rect,
                     const SkMatrix& combinedMatrix,
                     const SkRect& devRect) {
-        this->geometryFillAARect(target, ds, color, rect, combinedMatrix, devRect);
+        this->geometryFillAARect(target, ds, color, localMatrix, rect, combinedMatrix, devRect);
     }
 
     void strokeAARect(GrDrawTarget*,
                       GrDrawState*,
                       GrColor,
+                      const SkMatrix& localMatrix,
                       const SkRect& rect,
                       const SkMatrix& combinedMatrix,
                       const SkRect& devRect,
@@ -63,6 +65,7 @@ public:
     void fillAANestedRects(GrDrawTarget*,
                            GrDrawState*,
                            GrColor,
+                           const SkMatrix& localMatrix,
                            const SkRect rects[2],
                            const SkMatrix& combinedMatrix);
 
@@ -72,6 +75,7 @@ private:
     void geometryFillAARect(GrDrawTarget*,
                             GrDrawState*,
                             GrColor,
+                            const SkMatrix& localMatrix,
                             const SkRect& rect,
                             const SkMatrix& combinedMatrix,
                             const SkRect& devRect);
@@ -79,6 +83,7 @@ private:
     void geometryStrokeAARect(GrDrawTarget*,
                               GrDrawState*,
                               GrColor,
+                              const SkMatrix& localMatrix,
                               const SkRect& devOutside,
                               const SkRect& devOutsideAssist,
                               const SkRect& devInside,
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index e56f4dd77d..4b57868520 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -360,6 +360,7 @@ bool GrClipMaskManager::drawElement(GrDrawState* drawState,
                 this->getContext()->getAARectRenderer()->fillAARect(fClipTarget,
                                                                     drawState,
                                                                     color,
+                                                                    SkMatrix::I(),
                                                                     element->getRect(),
                                                                     SkMatrix::I(),
                                                                     element->getRect());
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index 2818aa92dd..13de4fec26 100755
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -743,23 +743,26 @@ void GrContext::drawRect(const GrPaint& paint,
                                            color);
 
     if (doAA) {
-        GrDrawState::AutoViewMatrixRestore avmr;
-        if (!avmr.setIdentity(&drawState)) {
+        SkMatrix invert;
+        if (!drawState.getViewMatrix().invert(&invert)) {
             return;
         }
+        GrDrawState::AutoViewMatrixRestore avmr(&drawState);
 
         if (width >= 0) {
             const SkStrokeRec& strokeRec = strokeInfo->getStrokeRec();
             fAARectRenderer->strokeAARect(target,
                                           &drawState,
                                           color,
+                                          invert,
                                           rect,
                                           matrix,
                                           devBoundRect,
                                           strokeRec);
         } else {
             // filled AA rect
-            fAARectRenderer->fillAARect(target, &drawState, color, rect, matrix, devBoundRect);
+            fAARectRenderer->fillAARect(target, &drawState, color, invert, rect, matrix,
+                                        devBoundRect);
         }
         return;
     }
@@ -1088,15 +1091,11 @@ void GrContext::drawPath(const GrPaint& paint,
             GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
             if (NULL == target) {
                 return;
-            };
+            }
 
-            SkMatrix origViewMatrix = drawState.getViewMatrix();
-            GrDrawState::AutoViewMatrixRestore avmr;
-            if (avmr.setIdentity(&drawState)) {
-                if (GrDashingEffect::DrawDashLine(fGpu, target, &drawState, color, pts, paint,
-                                                  strokeInfo, origViewMatrix)) {
-                    return;
-                }
+            if (GrDashingEffect::DrawDashLine(fGpu, target, &drawState, color, pts, paint,
+                                              strokeInfo)) {
+                return;
             }
         }
 
@@ -1138,12 +1137,15 @@ void GrContext::drawPath(const GrPaint& paint,
 
         if (is_nested_rects(target, &drawState, color, path, strokeRec, rects)) {
             SkMatrix origViewMatrix = drawState.getViewMatrix();
-            GrDrawState::AutoViewMatrixRestore avmr;
-            if (!avmr.setIdentity(&drawState)) {
+
+            SkMatrix invert;
+            if (!drawState.getViewMatrix().invert(&invert)) {
                 return;
             }
+            GrDrawState::AutoViewMatrixRestore avmr(&drawState);
 
-            fAARectRenderer->fillAANestedRects(target, &drawState, color, rects, origViewMatrix);
+            fAARectRenderer->fillAANestedRects(target, &drawState, color, invert, rects,
+                                               origViewMatrix);
             return;
         }
     }
diff --git a/src/gpu/GrDefaultPathRenderer.cpp b/src/gpu/GrDefaultPathRenderer.cpp
index 7222e628e8..e7c678d164 100644
--- a/src/gpu/GrDefaultPathRenderer.cpp
+++ b/src/gpu/GrDefaultPathRenderer.cpp
@@ -475,6 +475,8 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target,
             drawState->setXPFactory(backupXPFactory);
             SkRect bounds;
             GrDrawState::AutoViewMatrixRestore avmr;
+            const SkMatrix& viewMatrix = drawState->getViewMatrix();
+            SkMatrix localMatrix = SkMatrix::I();
             if (reverse) {
                 SkASSERT(drawState->getRenderTarget());
                 // draw over the dev bounds (which will be the whole dst surface for inv fill).
@@ -485,13 +487,16 @@ bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target,
                     drawState->getViewInverse(&vmi)) {
                     vmi.mapRect(&bounds);
                 } else {
+                    if (!viewMatrix.invert(&localMatrix)) {
+                        return false;
+                    }
                     avmr.setIdentity(drawState);
                 }
             } else {
                 bounds = path.getBounds();
             }
             GrDrawTarget::AutoGeometryPush agp(target);
-            target->drawSimpleRect(drawState, color, bounds);
+            target->drawRect(drawState, color, bounds, NULL, &localMatrix);
         } else {
             if (passCount > 1) {
                 drawState->setDisableColorXPFactory();
diff --git a/src/gpu/GrDrawState.cpp b/src/gpu/GrDrawState.cpp
index 643253efc0..67a356a1fa 100644
--- a/src/gpu/GrDrawState.cpp
+++ b/src/gpu/GrDrawState.cpp
@@ -211,93 +211,6 @@ bool GrDrawState::canTweakAlphaForCoverage() const {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void GrDrawState::AutoViewMatrixRestore::restore() {
-    if (fDrawState) {
-        SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
-        fDrawState->fViewMatrix = fViewMatrix;
-        SkASSERT(fDrawState->numColorStages() >= fNumColorStages);
-        int numCoverageStages = fSavedCoordChanges.count() - fNumColorStages;
-        SkASSERT(fDrawState->numCoverageStages() >= numCoverageStages);
-
-        int i = 0;
-        for (int s = 0; s < fNumColorStages; ++s, ++i) {
-            fDrawState->fColorStages[s].restoreCoordChange(fSavedCoordChanges[i]);
-        }
-        for (int s = 0; s < numCoverageStages; ++s, ++i) {
-            fDrawState->fCoverageStages[s].restoreCoordChange(fSavedCoordChanges[i]);
-        }
-        fDrawState = NULL;
-    }
-}
-
-void GrDrawState::AutoViewMatrixRestore::set(GrDrawState* drawState,
-                                             const SkMatrix& preconcatMatrix) {
-    this->restore();
-
-    SkASSERT(NULL == fDrawState);
-    if (NULL == drawState || preconcatMatrix.isIdentity()) {
-        return;
-    }
-    fDrawState = drawState;
-
-    fViewMatrix = drawState->getViewMatrix();
-    drawState->fViewMatrix.preConcat(preconcatMatrix);
-
-    this->doEffectCoordChanges(preconcatMatrix);
-    SkDEBUGCODE(++fDrawState->fBlockEffectRemovalCnt;)
-}
-
-bool GrDrawState::AutoViewMatrixRestore::setIdentity(GrDrawState* drawState) {
-    this->restore();
-
-    if (NULL == drawState) {
-        return false;
-    }
-
-    if (drawState->getViewMatrix().isIdentity()) {
-        return true;
-    }
-
-    fViewMatrix = drawState->getViewMatrix();
-    if (0 == drawState->numFragmentStages()) {
-        drawState->fViewMatrix.reset();
-        fDrawState = drawState;
-        fNumColorStages = 0;
-        fSavedCoordChanges.reset(0);
-        SkDEBUGCODE(++fDrawState->fBlockEffectRemovalCnt;)
-        return true;
-    } else {
-        SkMatrix inv;
-        if (!fViewMatrix.invert(&inv)) {
-            return false;
-        }
-        drawState->fViewMatrix.reset();
-        fDrawState = drawState;
-        this->doEffectCoordChanges(inv);
-        SkDEBUGCODE(++fDrawState->fBlockEffectRemovalCnt;)
-        return true;
-    }
-}
-
-void GrDrawState::AutoViewMatrixRestore::doEffectCoordChanges(const SkMatrix& coordChangeMatrix) {
-    fSavedCoordChanges.reset(fDrawState->numFragmentStages());
-    int i = 0;
-
-    fNumColorStages = fDrawState->numColorStages();
-    for (int s = 0; s < fNumColorStages; ++s, ++i) {
-        fDrawState->getColorStage(s).saveCoordChange(&fSavedCoordChanges[i]);
-        fDrawState->fColorStages[s].localCoordChange(coordChangeMatrix);
-    }
-
-    int numCoverageStages = fDrawState->numCoverageStages();
-    for (int s = 0; s < numCoverageStages; ++s, ++i) {
-        fDrawState->getCoverageStage(s).saveCoordChange(&fSavedCoordChanges[i]);
-        fDrawState->fCoverageStages[s].localCoordChange(coordChangeMatrix);
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 GrDrawState::~GrDrawState() {
     SkASSERT(0 == fBlockEffectRemovalCnt);
 }
diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h
index 36e2b3a2fb..1f469d537e 100644
--- a/src/gpu/GrDrawState.h
+++ b/src/gpu/GrDrawState.h
@@ -306,40 +306,41 @@ public:
     ////////////////////////////////////////////////////////////////////////////
 
     /**
-     * Preconcats the current view matrix and restores the previous view matrix in the destructor.
-     * Effect matrices are automatically adjusted to compensate and adjusted back in the destructor.
+     * Sets the viewmatrix to identity and restores it in the destructor.
+     * TODO remove vm off of drawstate
      */
     class AutoViewMatrixRestore : public ::SkNoncopyable {
     public:
-        AutoViewMatrixRestore() : fDrawState(NULL) {}
-
-        AutoViewMatrixRestore(GrDrawState* ds, const SkMatrix& preconcatMatrix) {
+        AutoViewMatrixRestore() {
             fDrawState = NULL;
-            this->set(ds, preconcatMatrix);
         }
 
-        ~AutoViewMatrixRestore() { this->restore(); }
-
-        /**
-         * Can be called prior to destructor to restore the original matrix.
-         */
-        void restore();
+        AutoViewMatrixRestore(GrDrawState* ds) {
+            SkASSERT(ds);
+            fDrawState = ds;
+            fViewMatrix = fDrawState->fViewMatrix;
+            fDrawState->fViewMatrix = SkMatrix::I();
+        }
 
-        void set(GrDrawState* drawState, const SkMatrix& preconcatMatrix);
+        void setIdentity(GrDrawState* ds) {
+            SkASSERT(ds);
+            fDrawState = ds;
+            fViewMatrix = fDrawState->fViewMatrix;
+            fDrawState->fViewMatrix = SkMatrix::I();
+        }
 
-        /** Sets the draw state's matrix to identity. This can fail because the current view matrix
-            is not invertible. */
-        bool setIdentity(GrDrawState* drawState);
+        ~AutoViewMatrixRestore() {
+            if (fDrawState) {
+                fDrawState->fViewMatrix = fViewMatrix;
+            }
+        }
 
     private:
-        void doEffectCoordChanges(const SkMatrix& coordChangeMatrix);
-
         GrDrawState*                                           fDrawState;
         SkMatrix                                               fViewMatrix;
-        int                                                    fNumColorStages;
-        SkAutoSTArray<8, GrFragmentStage::SavedCoordChange>    fSavedCoordChanges;
     };
 
+
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/GrInOrderDrawBuffer.cpp b/src/gpu/GrInOrderDrawBuffer.cpp
index 6e5c1fe778..1f49035919 100644
--- a/src/gpu/GrInOrderDrawBuffer.cpp
+++ b/src/gpu/GrInOrderDrawBuffer.cpp
@@ -120,11 +120,27 @@ void GrInOrderDrawBuffer::onDrawRect(GrDrawState* ds,
                                      const SkMatrix* localMatrix) {
     GrDrawState::AutoRestoreEffects are(ds);
 
+    // Go to device coords to allow batching across matrix changes
+    SkMatrix matrix = ds->getViewMatrix();
+    SkMatrix invert = SkMatrix::I();
+
+    // if we have a local rect, then we apply the localMatrix directly to the localRect to generate
+    // vertex local coords
     bool hasExplicitLocalCoords = SkToBool(localRect);
-    SkAutoTUnref<const GrGeometryProcessor> gp(
-            create_rect_gp(hasExplicitLocalCoords,
-                           color,
-                           hasExplicitLocalCoords ? NULL : localMatrix));
+    if (!hasExplicitLocalCoords) {
+        if (!matrix.isIdentity() && !matrix.invert(&invert)) {
+            SkDebugf("Could not invert\n");
+            return;
+        }
+
+        if (localMatrix) {
+            invert.preConcat(*localMatrix);
+        }
+    }
+
+    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(hasExplicitLocalCoords,
+                                                              color,
+                                                              &invert));
 
     size_t vstride = gp->getVertexStride();
     SkASSERT(vstride == sizeof(SkPoint) + sizeof(GrColor) + (SkToBool(localRect) ? sizeof(SkPoint) :
@@ -135,16 +151,10 @@ void GrInOrderDrawBuffer::onDrawRect(GrDrawState* ds,
         return;
     }
 
-    // Go to device coords to allow batching across matrix changes
-    SkMatrix matrix = ds->getViewMatrix();
-
     // When the caller has provided an explicit source rect for a stage then we don't want to
     // modify that stage's matrix. Otherwise if the effect is generating its source rect from
     // the vertex positions then we have to account for the view matrix change.
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(ds)) {
-        return;
-    }
+    GrDrawState::AutoViewMatrixRestore avmr(ds);
 
     geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vstride);
     matrix.mapPointsWithStride(geo.positions(), vstride, 4);
diff --git a/src/gpu/GrOvalRenderer.cpp b/src/gpu/GrOvalRenderer.cpp
index 05838cf6e5..ac088b93e6 100644
--- a/src/gpu/GrOvalRenderer.cpp
+++ b/src/gpu/GrOvalRenderer.cpp
@@ -65,8 +65,8 @@ inline bool circle_stays_circle(const SkMatrix& m) {
 
 class CircleEdgeEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color, bool stroke) {
-        return SkNEW_ARGS(CircleEdgeEffect, (color, stroke));
+    static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(CircleEdgeEffect, (color, stroke, localMatrix));
     }
 
     const GrAttribute* inPosition() const { return fInPosition; }
@@ -174,7 +174,8 @@ public:
     }
 
 private:
-    CircleEdgeEffect(GrColor color, bool stroke) : INHERITED(color) {
+    CircleEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix)
+        : INHERITED(color, false, localMatrix) {
         this->initClassID<CircleEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInCircleEdge = &this->addVertexAttrib(GrAttribute("inCircleEdge",
@@ -212,7 +213,8 @@ GrGeometryProcessor* CircleEdgeEffect::TestCreate(SkRandom* random,
                                                   GrContext* context,
                                                   const GrDrawTargetCaps&,
                                                   GrTexture* textures[]) {
-    return CircleEdgeEffect::Create(GrRandomColor(random), random->nextBool());
+    return CircleEdgeEffect::Create(GrRandomColor(random), random->nextBool(),
+                                    GrProcessorUnitTest::TestMatrix(random));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -227,8 +229,8 @@ GrGeometryProcessor* CircleEdgeEffect::TestCreate(SkRandom* random,
 
 class EllipseEdgeEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color, bool stroke) {
-        return SkNEW_ARGS(EllipseEdgeEffect, (color, stroke));
+    static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(EllipseEdgeEffect, (color, stroke, localMatrix));
     }
 
     virtual ~EllipseEdgeEffect() {}
@@ -360,7 +362,8 @@ public:
     }
 
 private:
-    EllipseEdgeEffect(GrColor color, bool stroke) : INHERITED(color) {
+    EllipseEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix)
+        : INHERITED(color, false, localMatrix) {
         this->initClassID<EllipseEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInEllipseOffset = &this->addVertexAttrib(GrAttribute("inEllipseOffset",
@@ -401,7 +404,8 @@ GrGeometryProcessor* EllipseEdgeEffect::TestCreate(SkRandom* random,
                                                    GrContext* context,
                                                    const GrDrawTargetCaps&,
                                                    GrTexture* textures[]) {
-    return EllipseEdgeEffect::Create(GrRandomColor(random), random->nextBool());
+    return EllipseEdgeEffect::Create(GrRandomColor(random), random->nextBool(),
+                                     GrProcessorUnitTest::TestMatrix(random));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -667,11 +671,13 @@ void GrOvalRenderer::drawCircle(GrDrawTarget* target,
     SkScalar radius = vm.mapRadius(SkScalarHalf(circle.width()));
     SkScalar strokeWidth = vm.mapRadius(stroke.getWidth());
 
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    SkMatrix invert;
+    if (!vm.invert(&invert)) {
         return;
     }
 
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     SkStrokeRec::Style style = stroke.getStyle();
     bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
                         SkStrokeRec::kHairline_Style == style;
@@ -694,7 +700,7 @@ void GrOvalRenderer::drawCircle(GrDrawTarget* target,
     }
 
     SkAutoTUnref<GrGeometryProcessor> gp(
-            CircleEdgeEffect::Create(color, isStrokeOnly && innerRadius > 0));
+            CircleEdgeEffect::Create(color, isStrokeOnly && innerRadius > 0, invert));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, gp->getVertexStride(),  0);
     SkASSERT(gp->getVertexStride() == sizeof(CircleVertex));
@@ -816,13 +822,16 @@ bool GrOvalRenderer::drawEllipse(GrDrawTarget* target,
         yRadius += scaledStroke.fY;
     }
 
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    SkMatrix invert;
+    if (!vm.invert(&invert)) {
         return false;
     }
 
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     SkAutoTUnref<GrGeometryProcessor> gp(
-            EllipseEdgeEffect::Create(color, isStrokeOnly && innerXRadius > 0 && innerYRadius > 0));
+            EllipseEdgeEffect::Create(color, isStrokeOnly && innerXRadius > 0 && innerYRadius > 0,
+                                      invert));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, gp->getVertexStride(),  0);
     SkASSERT(gp->getVertexStride() == sizeof(EllipseVertex));
@@ -1084,16 +1093,19 @@ bool GrOvalRenderer::drawDRRect(GrDrawTarget* target,
     if (!are.isSet()) {
         are.set(drawState);
     }
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+
+    SkMatrix invert;
+    if (!drawState->getViewMatrix().invert(&invert)) {
         return false;
     }
+
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
     drawState->addCoverageProcessor(effect)->unref();
     SkRect bounds = outer->getBounds();
     if (applyAA) {
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
     }
-    target->drawSimpleRect(drawState, color, bounds);
+    target->drawRect(drawState, color, bounds, NULL, &invert);
     return true;
 }
 
@@ -1169,11 +1181,14 @@ bool GrOvalRenderer::drawRRect(GrDrawTarget* target,
     }
 
     // reset to device coordinates
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    SkMatrix invert;
+    if (!vm.invert(&invert)) {
+        SkDebugf("Failed to invert\n");
         return false;
     }
 
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     GrIndexBuffer* indexBuffer = this->rRectIndexBuffer(isStrokeOnly);
     if (NULL == indexBuffer) {
         SkDebugf("Failed to create index buffer!\n");
@@ -1201,7 +1216,8 @@ bool GrOvalRenderer::drawRRect(GrDrawTarget* target,
 
         isStrokeOnly = (isStrokeOnly && innerRadius >= 0);
 
-        SkAutoTUnref<GrGeometryProcessor> effect(CircleEdgeEffect::Create(color, isStrokeOnly));
+        SkAutoTUnref<GrGeometryProcessor> effect(CircleEdgeEffect::Create(color, isStrokeOnly,
+                                                                          invert));
 
         GrDrawTarget::AutoReleaseGeometry geo(target, 16, effect->getVertexStride(),  0);
         SkASSERT(effect->getVertexStride() == sizeof(CircleVertex));
@@ -1300,7 +1316,8 @@ bool GrOvalRenderer::drawRRect(GrDrawTarget* target,
 
         isStrokeOnly = (isStrokeOnly && innerXRadius >= 0 && innerYRadius >= 0);
 
-        SkAutoTUnref<GrGeometryProcessor> effect(EllipseEdgeEffect::Create(color, isStrokeOnly));
+        SkAutoTUnref<GrGeometryProcessor> effect(EllipseEdgeEffect::Create(color, isStrokeOnly,
+                                                                           invert));
 
         GrDrawTarget::AutoReleaseGeometry geo(target, 16, effect->getVertexStride(),  0);
         SkASSERT(effect->getVertexStride() == sizeof(EllipseVertex));
diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp
index 61e7f1f960..b64d37bdb8 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -350,10 +350,11 @@ void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture,
                                               GrDrawState* drawState,
                                               GrColor color,
                                               const SkIRect& rect) {
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    SkMatrix invert;
+    if (!drawState->getViewMatrix().invert(&invert)) {
         return;
     }
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
     GrDrawState::AutoRestoreEffects are(drawState);
 
     SkRect dstRect = SkRect::MakeLTRB(SK_Scalar1 * rect.fLeft,
@@ -374,5 +375,5 @@ void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture,
                                                        GrTextureParams::kNone_FilterMode,
                                                        kDevice_GrCoordSet))->unref();
 
-    target->drawSimpleRect(drawState, color, dstRect);
+    target->drawRect(drawState, color, dstRect, NULL, &invert);
 }
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index 157e81d108..8eb66d81bf 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -81,30 +81,34 @@ void draw_around_inv_path(GrDrawTarget* target,
                           GrColor color,
                           const SkIRect& devClipBounds,
                           const SkIRect& devPathBounds) {
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    const SkMatrix& matrix = drawState->getViewMatrix();
+    SkMatrix invert;
+    if (!matrix.invert(&invert)) {
         return;
     }
+
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     SkRect rect;
     if (devClipBounds.fTop < devPathBounds.fTop) {
         rect.iset(devClipBounds.fLeft, devClipBounds.fTop,
                   devClipBounds.fRight, devPathBounds.fTop);
-        target->drawSimpleRect(drawState, color, rect);
+        target->drawRect(drawState, color, rect, NULL, &invert);
     }
     if (devClipBounds.fLeft < devPathBounds.fLeft) {
         rect.iset(devClipBounds.fLeft, devPathBounds.fTop,
                   devPathBounds.fLeft, devPathBounds.fBottom);
-        target->drawSimpleRect(drawState, color, rect);
+        target->drawRect(drawState, color, rect, NULL, &invert);
     }
     if (devClipBounds.fRight > devPathBounds.fRight) {
         rect.iset(devPathBounds.fRight, devPathBounds.fTop,
                   devClipBounds.fRight, devPathBounds.fBottom);
-        target->drawSimpleRect(drawState, color, rect);
+        target->drawRect(drawState, color, rect, NULL, &invert);
     }
     if (devClipBounds.fBottom > devPathBounds.fBottom) {
         rect.iset(devClipBounds.fLeft, devPathBounds.fBottom,
                   devClipBounds.fRight, devClipBounds.fBottom);
-        target->drawSimpleRect(drawState, color, rect);
+        target->drawRect(drawState, color, rect, NULL, &invert);
     }
 }
 
diff --git a/src/gpu/GrStencilAndCoverPathRenderer.cpp b/src/gpu/GrStencilAndCoverPathRenderer.cpp
index d8470f3c8c..2feea01e5b 100644
--- a/src/gpu/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/GrStencilAndCoverPathRenderer.cpp
@@ -121,6 +121,7 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(GrDrawTarget* target,
         SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(GrColor_WHITE));
         target->stencilPath(drawState, pp, p, convert_skpath_filltype(path.getFillType()));
 
+        SkMatrix invert = SkMatrix::I();
         GrDrawState::AutoViewMatrixRestore avmr;
         SkRect bounds = SkRect::MakeLTRB(0, 0,
                                          SkIntToScalar(drawState->getRenderTarget()->width()),
@@ -134,9 +135,12 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(GrDrawTarget* target,
             SkScalar bloat = drawState->getViewMatrix().getMaxScale() * SK_ScalarHalf;
             bounds.outset(bloat, bloat);
         } else {
+            if (!drawState->getViewMatrix().invert(&invert)) {
+                return false;
+            }
             avmr.setIdentity(drawState);
         }
-        target->drawSimpleRect(drawState, color, bounds);
+        target->drawRect(drawState, color, bounds, NULL, &invert);
     } else {
         GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
             kZero_StencilOp,
diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp
index 0ba7beeb88..c90067d4a4 100644
--- a/src/gpu/effects/GrBezierEffect.cpp
+++ b/src/gpu/effects/GrBezierEffect.cpp
@@ -183,8 +183,9 @@ GrGLGeometryProcessor* GrConicEffect::createGLInstance(const GrBatchTracker& bt)
     return SkNEW_ARGS(GrGLConicEffect, (*this, bt));
 }
 
-GrConicEffect::GrConicEffect(GrColor color, uint8_t coverage, GrPrimitiveEdgeType edgeType)
-    : INHERITED(color, false), fCoverageScale(coverage), fEdgeType(edgeType) {
+GrConicEffect::GrConicEffect(GrColor color, uint8_t coverage, GrPrimitiveEdgeType edgeType,
+                             const SkMatrix& localMatrix)
+    : INHERITED(color, false, localMatrix), fCoverageScale(coverage), fEdgeType(edgeType) {
     this->initClassID<GrConicEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInConicCoeffs = &this->addVertexAttrib(GrAttribute("inConicCoeffs",
@@ -227,7 +228,8 @@ GrGeometryProcessor* GrConicEffect::TestCreate(SkRandom* random,
     do {
         GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                                                     random->nextULessThan(kGrProcessorEdgeTypeCnt));
-        gp = GrConicEffect::Create(GrRandomColor(random), edgeType, caps);
+        gp = GrConicEffect::Create(GrRandomColor(random), edgeType, caps,
+                                   GrProcessorUnitTest::TestMatrix(random));
     } while (NULL == gp);
     return gp;
 }
@@ -393,8 +395,9 @@ GrGLGeometryProcessor* GrQuadEffect::createGLInstance(const GrBatchTracker& bt)
     return SkNEW_ARGS(GrGLQuadEffect, (*this, bt));
 }
 
-GrQuadEffect::GrQuadEffect(GrColor color, uint8_t coverage, GrPrimitiveEdgeType edgeType)
-    : INHERITED(color, false), fCoverageScale(coverage), fEdgeType(edgeType) {
+GrQuadEffect::GrQuadEffect(GrColor color, uint8_t coverage, GrPrimitiveEdgeType edgeType,
+                           const SkMatrix& localMatrix)
+    : INHERITED(color, false, localMatrix), fCoverageScale(coverage), fEdgeType(edgeType) {
     this->initClassID<GrQuadEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInHairQuadEdge = &this->addVertexAttrib(GrAttribute("inHairQuadEdge",
@@ -437,7 +440,8 @@ GrGeometryProcessor* GrQuadEffect::TestCreate(SkRandom* random,
     do {
         GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                 random->nextULessThan(kGrProcessorEdgeTypeCnt));
-        gp = GrQuadEffect::Create(GrRandomColor(random), edgeType, caps);
+        gp = GrQuadEffect::Create(GrRandomColor(random), edgeType, caps,
+                                  GrProcessorUnitTest::TestMatrix(random));
     } while (NULL == gp);
     return gp;
 }
diff --git a/src/gpu/effects/GrBezierEffect.h b/src/gpu/effects/GrBezierEffect.h
index 5954ee36df..b985feccf6 100644
--- a/src/gpu/effects/GrBezierEffect.h
+++ b/src/gpu/effects/GrBezierEffect.h
@@ -61,21 +61,25 @@ public:
     static GrGeometryProcessor* Create(GrColor color,
                                        const GrPrimitiveEdgeType edgeType,
                                        const GrDrawTargetCaps& caps,
+                                       const SkMatrix& localMatrix,
                                        uint8_t coverage = 0xff) {
         switch (edgeType) {
             case kFillAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
                 }
-                return SkNEW_ARGS(GrConicEffect, (color, coverage, kFillAA_GrProcessorEdgeType));
+                return SkNEW_ARGS(GrConicEffect, (color, coverage, kFillAA_GrProcessorEdgeType,
+                                                  localMatrix));
             case kHairlineAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
                 }
                 return SkNEW_ARGS(GrConicEffect, (color, coverage,
-                                                  kHairlineAA_GrProcessorEdgeType));
+                                                  kHairlineAA_GrProcessorEdgeType,
+                                                  localMatrix));
             case kFillBW_GrProcessorEdgeType:
-                return SkNEW_ARGS(GrConicEffect, (color, coverage, kFillBW_GrProcessorEdgeType));;
+                return SkNEW_ARGS(GrConicEffect, (color, coverage, kFillBW_GrProcessorEdgeType,
+                                                  localMatrix));
             default:
                 return NULL;
         }
@@ -103,7 +107,7 @@ public:
                         const GrBatchTracker&) const SK_OVERRIDE;
 
 private:
-    GrConicEffect(GrColor, uint8_t coverage, GrPrimitiveEdgeType);
+    GrConicEffect(GrColor, uint8_t coverage, GrPrimitiveEdgeType, const SkMatrix& localMatrix);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
@@ -137,20 +141,24 @@ public:
     static GrGeometryProcessor* Create(GrColor color,
                                        const GrPrimitiveEdgeType edgeType,
                                        const GrDrawTargetCaps& caps,
+                                       const SkMatrix& localMatrix,
                                        uint8_t coverage = 0xff) {
         switch (edgeType) {
             case kFillAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
                 }
-                return SkNEW_ARGS(GrQuadEffect, (color, coverage, kFillAA_GrProcessorEdgeType));
+                return SkNEW_ARGS(GrQuadEffect, (color, coverage, kFillAA_GrProcessorEdgeType,
+                                                 localMatrix));
             case kHairlineAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
                 }
-                return SkNEW_ARGS(GrQuadEffect, (color, coverage, kHairlineAA_GrProcessorEdgeType));
+                return SkNEW_ARGS(GrQuadEffect, (color, coverage, kHairlineAA_GrProcessorEdgeType,
+                                                 localMatrix));
             case kFillBW_GrProcessorEdgeType:
-                return SkNEW_ARGS(GrQuadEffect, (color, coverage, kFillBW_GrProcessorEdgeType));
+                return SkNEW_ARGS(GrQuadEffect, (color, coverage, kFillBW_GrProcessorEdgeType,
+                                                 localMatrix));
             default:
                 return NULL;
         }
@@ -178,7 +186,7 @@ public:
                         const GrBatchTracker&) const SK_OVERRIDE;
 
 private:
-    GrQuadEffect(GrColor, uint8_t coverage, GrPrimitiveEdgeType);
+    GrQuadEffect(GrColor, uint8_t coverage, GrPrimitiveEdgeType, const SkMatrix& localMatrix);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
diff --git a/src/gpu/effects/GrDashingEffect.cpp b/src/gpu/effects/GrDashingEffect.cpp
index d5b0b48e9b..339e44a83c 100644
--- a/src/gpu/effects/GrDashingEffect.cpp
+++ b/src/gpu/effects/GrDashingEffect.cpp
@@ -166,7 +166,8 @@ static void setup_dashed_rect_pos(const SkRect& rect, int idx, const SkMatrix& m
 
 bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target, GrDrawState* drawState,
                                    GrColor color, const SkPoint pts[2], const GrPaint& paint,
-                                   const GrStrokeInfo& strokeInfo, const SkMatrix& vm) {
+                                   const GrStrokeInfo& strokeInfo) {
+    const SkMatrix& vm = drawState->getViewMatrix();
 
     if (!can_fast_path_dash(pts, strokeInfo, *target, *drawState, vm)) {
         return false;
@@ -335,6 +336,15 @@ bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target, GrDrawState
         devIntervals[0] = lineLength;
     }
 
+    // reset to device coordinates
+    SkMatrix invert;
+    if (!vm.invert(&invert)) {
+        SkDebugf("Failed to invert\n");
+        return false;
+    }
+
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     SkAutoTUnref<const GrGeometryProcessor> gp;
     bool fullDash = devIntervals[1] > 0.f || useAA;
     if (fullDash) {
@@ -347,10 +357,11 @@ bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target, GrDrawState
         bool isRoundCap = SkPaint::kRound_Cap == cap;
         GrDashingEffect::DashCap capType = isRoundCap ? GrDashingEffect::kRound_DashCap :
                                                         GrDashingEffect::kNonRound_DashCap;
-        gp.reset(GrDashingEffect::Create(color, edgeType, devInfo, strokeWidth, capType));
+        gp.reset(GrDashingEffect::Create(color, edgeType, devInfo, strokeWidth, capType, invert));
     } else {
         // Set up the vertex data for the line and start/end dashes
-        gp.reset(GrDefaultGeoProcFactory::Create(color, GrDefaultGeoProcFactory::kPosition_GPType));
+        gp.reset(GrDefaultGeoProcFactory::Create(color, GrDefaultGeoProcFactory::kPosition_GPType,
+                                                 invert));
     }
 
     int totalRectCnt = 0;
@@ -464,7 +475,8 @@ public:
     static GrGeometryProcessor* Create(GrColor,
                                        GrPrimitiveEdgeType edgeType,
                                        const DashInfo& info,
-                                       SkScalar radius);
+                                       SkScalar radius,
+                                       const SkMatrix& localMatrix);
 
     virtual ~DashingCircleEffect();
 
@@ -496,7 +508,7 @@ public:
 
 private:
     DashingCircleEffect(GrColor, GrPrimitiveEdgeType edgeType, const DashInfo& info,
-                        SkScalar radius);
+                        SkScalar radius, const SkMatrix& localMatrix);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
@@ -633,12 +645,13 @@ void GLDashingCircleEffect::GenKey(const GrGeometryProcessor& processor,
 GrGeometryProcessor* DashingCircleEffect::Create(GrColor color,
                                                  GrPrimitiveEdgeType edgeType,
                                                  const DashInfo& info,
-                                                 SkScalar radius) {
+                                                 SkScalar radius,
+                                                 const SkMatrix& localMatrix) {
     if (info.fCount != 2 || info.fIntervals[0] != 0) {
         return NULL;
     }
 
-    return SkNEW_ARGS(DashingCircleEffect, (color, edgeType, info, radius));
+    return SkNEW_ARGS(DashingCircleEffect, (color, edgeType, info, radius, localMatrix));
 }
 
 DashingCircleEffect::~DashingCircleEffect() {}
@@ -660,8 +673,9 @@ GrGLGeometryProcessor* DashingCircleEffect::createGLInstance(const GrBatchTracke
 DashingCircleEffect::DashingCircleEffect(GrColor color,
                                          GrPrimitiveEdgeType edgeType,
                                          const DashInfo& info,
-                                         SkScalar radius)
-    : INHERITED(color), fEdgeType(edgeType) {
+                                         SkScalar radius,
+                                         const SkMatrix& localMatrix)
+    : INHERITED(color, false, localMatrix), fEdgeType(edgeType) {
     this->initClassID<DashingCircleEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttribType));
@@ -714,7 +728,8 @@ GrGeometryProcessor* DashingCircleEffect::TestCreate(SkRandom* random,
     info.fIntervals[1] = random->nextRangeScalar(0, 10.f);
     info.fPhase = random->nextRangeScalar(0, info.fIntervals[1]);
 
-    return DashingCircleEffect::Create(GrRandomColor(random), edgeType, info, strokeWidth);
+    return DashingCircleEffect::Create(GrRandomColor(random), edgeType, info, strokeWidth,
+                                       GrProcessorUnitTest::TestMatrix(random));
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -743,7 +758,8 @@ public:
     static GrGeometryProcessor* Create(GrColor,
                                        GrPrimitiveEdgeType edgeType,
                                        const DashInfo& info,
-                                       SkScalar strokeWidth);
+                                       SkScalar strokeWidth,
+                                       const SkMatrix& localMatrix);
 
     virtual ~DashingLineEffect();
 
@@ -773,7 +789,7 @@ public:
 
 private:
     DashingLineEffect(GrColor, GrPrimitiveEdgeType edgeType, const DashInfo& info,
-                      SkScalar strokeWidth);
+                      SkScalar strokeWidth, const SkMatrix& localMatrix);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
@@ -923,12 +939,13 @@ void GLDashingLineEffect::GenKey(const GrGeometryProcessor& processor,
 GrGeometryProcessor* DashingLineEffect::Create(GrColor color,
                                                GrPrimitiveEdgeType edgeType,
                                                const DashInfo& info,
-                                               SkScalar strokeWidth) {
+                                               SkScalar strokeWidth,
+                                               const SkMatrix& localMatrix) {
     if (info.fCount != 2) {
         return NULL;
     }
 
-    return SkNEW_ARGS(DashingLineEffect, (color, edgeType, info, strokeWidth));
+    return SkNEW_ARGS(DashingLineEffect, (color, edgeType, info, strokeWidth, localMatrix));
 }
 
 DashingLineEffect::~DashingLineEffect() {}
@@ -950,8 +967,9 @@ GrGLGeometryProcessor* DashingLineEffect::createGLInstance(const GrBatchTracker&
 DashingLineEffect::DashingLineEffect(GrColor color,
                                      GrPrimitiveEdgeType edgeType,
                                      const DashInfo& info,
-                                     SkScalar strokeWidth)
-    : INHERITED(color), fEdgeType(edgeType) {
+                                     SkScalar strokeWidth,
+                                     const SkMatrix& localMatrix)
+    : INHERITED(color, false, localMatrix), fEdgeType(edgeType) {
     this->initClassID<DashingLineEffect>();
     fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
     fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttribType));
@@ -1004,7 +1022,8 @@ GrGeometryProcessor* DashingLineEffect::TestCreate(SkRandom* random,
     info.fIntervals[1] = random->nextRangeScalar(0, 10.f);
     info.fPhase = random->nextRangeScalar(0, info.fIntervals[0] + info.fIntervals[1]);
 
-    return DashingLineEffect::Create(GrRandomColor(random), edgeType, info, strokeWidth);
+    return DashingLineEffect::Create(GrRandomColor(random), edgeType, info, strokeWidth,
+                                     GrProcessorUnitTest::TestMatrix(random));
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -1013,12 +1032,14 @@ GrGeometryProcessor* GrDashingEffect::Create(GrColor color,
                                              GrPrimitiveEdgeType edgeType,
                                              const SkPathEffect::DashInfo& info,
                                              SkScalar strokeWidth,
-                                             GrDashingEffect::DashCap cap) {
+                                             GrDashingEffect::DashCap cap,
+                                             const SkMatrix& localMatrix) {
     switch (cap) {
         case GrDashingEffect::kRound_DashCap:
-            return DashingCircleEffect::Create(color, edgeType, info, SkScalarHalf(strokeWidth));
+            return DashingCircleEffect::Create(color, edgeType, info, SkScalarHalf(strokeWidth),
+                                               localMatrix);
         case GrDashingEffect::kNonRound_DashCap:
-            return DashingLineEffect::Create(color, edgeType, info, strokeWidth);
+            return DashingLineEffect::Create(color, edgeType, info, strokeWidth, localMatrix);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
diff --git a/src/gpu/effects/GrDashingEffect.h b/src/gpu/effects/GrDashingEffect.h
index 492c6905fc..61cba7e533 100644
--- a/src/gpu/effects/GrDashingEffect.h
+++ b/src/gpu/effects/GrDashingEffect.h
@@ -25,8 +25,7 @@ class SkPath;
 
 namespace GrDashingEffect {
     bool DrawDashLine(GrGpu*, GrDrawTarget*, GrDrawState*, GrColor, const SkPoint pts[2],
-                      const GrPaint& paint, const GrStrokeInfo& strokeInfo,
-                      const SkMatrix& vm);
+                      const GrPaint& paint, const GrStrokeInfo& strokeInfo);
 
     enum DashCap {
         kRound_DashCap,
@@ -43,7 +42,8 @@ namespace GrDashingEffect {
                                 GrPrimitiveEdgeType edgeType,
                                 const SkPathEffect::DashInfo& info,
                                 SkScalar strokeWidth,
-                                DashCap cap);
+                                DashCap cap,
+                                const SkMatrix& localMatrix);
 }
 
 #endif