Move ViewMatrix off of drawstate

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrProcessor.h"
@@ skipping 47 matching lines @@
  * with origin at the circle center. Two   vertex attributes are used:
  *    vec2f : position in device space of the bounding geometry vertices
  *    vec4f : (p.xy, outerRad, innerRad)
  *             p is the position in the normalized space.
  *             outerRad is the outerRadius in device space.
  *             innerRad is the innerRadius in normalized space (ignored if not stroking).
  */
 
 class CircleEdgeEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix) {
-        return SkNEW_ARGS(CircleEdgeEffect, (color, stroke, localMatrix));
+    static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, bool stroke,
+                                       const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(CircleEdgeEffect, (color, viewMatrix, stroke, localMatrix));
     }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inCircleEdge() const { return fInCircleEdge; }
     virtual ~CircleEdgeEffect() {}
 
     virtual const char* name() const SK_OVERRIDE { return "CircleEdge"; }
 
     inline bool isStroked() const { return fStroke; }
 
@@ skipping 87 matching lines @@
                         const GrBatchTracker& t) const SK_OVERRIDE {
         const BatchTracker& mine = m.cast<BatchTracker>();
         const BatchTracker& theirs = t.cast<BatchTracker>();
         return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                        that, theirs.fUsesLocalCoords) &&
                CanCombineOutput(mine.fInputColorType, mine.fColor,
                                 theirs.fInputColorType, theirs.fColor);
     }
 
 private:
-    CircleEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix)
-        : INHERITED(color, false, localMatrix) {
+    CircleEdgeEffect(GrColor color, const SkMatrix& viewMatrix, bool stroke,
+                     const SkMatrix& localMatrix)
+        : INHERITED(color, viewMatrix, localMatrix) {
         this->initClassID<CircleEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInCircleEdge = &this->addVertexAttrib(GrAttribute("inCircleEdge",
                                                            kVec4f_GrVertexAttribType));
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         const CircleEdgeEffect& cee = other.cast<CircleEdgeEffect>();
         return cee.fStroke == fStroke;
@@ skipping 17 matching lines @@
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(CircleEdgeEffect);
 
 GrGeometryProcessor* CircleEdgeEffect::TestCreate(SkRandom* random,
                                                   GrContext* context,
                                                   const GrDrawTargetCaps&,
                                                   GrTexture* textures[]) {
-    return CircleEdgeEffect::Create(GrRandomColor(random), random->nextBool(),
+    return CircleEdgeEffect::Create(GrRandomColor(random),
+                                    GrProcessorUnitTest::TestMatrix(random),
+                                    random->nextBool(),
                                     GrProcessorUnitTest::TestMatrix(random));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * The output of this effect is a modulation of the input color and coverage for an axis-aligned
  * ellipse, specified as a 2D offset from center, and the reciprocals of the outer and inner radii,
  * in both x and y directions.
  *
  * We are using an implicit function of x^2/a^2 + y^2/b^2 - 1 = 0.
  */
 
 class EllipseEdgeEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix) {
-        return SkNEW_ARGS(EllipseEdgeEffect, (color, stroke, localMatrix));
+    static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, bool stroke,
+                                       const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(EllipseEdgeEffect, (color, viewMatrix, stroke, localMatrix));
     }
 
     virtual ~EllipseEdgeEffect() {}
 
     virtual const char* name() const SK_OVERRIDE { return "EllipseEdge"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inEllipseOffset() const { return fInEllipseOffset; }
     const GrAttribute* inEllipseRadii() const { return fInEllipseRadii; }
 
@@ skipping 111 matching lines @@
                         const GrBatchTracker& t) const SK_OVERRIDE {
         const BatchTracker& mine = m.cast<BatchTracker>();
         const BatchTracker& theirs = t.cast<BatchTracker>();
         return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                        that, theirs.fUsesLocalCoords) &&
                CanCombineOutput(mine.fInputColorType, mine.fColor,
                                 theirs.fInputColorType, theirs.fColor);
     }
 
 private:
-    EllipseEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix)
-        : INHERITED(color, false, localMatrix) {
+    EllipseEdgeEffect(GrColor color, const SkMatrix& viewMatrix, bool stroke,
+                      const SkMatrix& localMatrix)
+        : INHERITED(color, viewMatrix, localMatrix) {
         this->initClassID<EllipseEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInEllipseOffset = &this->addVertexAttrib(GrAttribute("inEllipseOffset",
                                                               kVec2f_GrVertexAttribType));
         fInEllipseRadii = &this->addVertexAttrib(GrAttribute("inEllipseRadii",
                                                              kVec4f_GrVertexAttribType));
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
@@ skipping 20 matching lines @@
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(EllipseEdgeEffect);
 
 GrGeometryProcessor* EllipseEdgeEffect::TestCreate(SkRandom* random,
                                                    GrContext* context,
                                                    const GrDrawTargetCaps&,
                                                    GrTexture* textures[]) {
-    return EllipseEdgeEffect::Create(GrRandomColor(random), random->nextBool(),
+    return EllipseEdgeEffect::Create(GrRandomColor(random),
+                                     GrProcessorUnitTest::TestMatrix(random),
+                                     random->nextBool(),
                                      GrProcessorUnitTest::TestMatrix(random));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * The output of this effect is a modulation of the input color and coverage for an ellipse,
  * specified as a 2D offset from center for both the outer and inner paths (if stroked). The
  * implict equation used is for a unit circle (x^2 + y^2 - 1 = 0) and the edge corrected by
  * using differentials.
  *
  * The result is device-independent and can be used with any affine matrix.
  */
 
 class DIEllipseEdgeEffect : public GrGeometryProcessor {
 public:
     enum Mode { kStroke = 0, kHairline, kFill };
 
-    static GrGeometryProcessor* Create(GrColor color, Mode mode) {
-        return SkNEW_ARGS(DIEllipseEdgeEffect, (color, mode));
+    static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, Mode mode) {
+        return SkNEW_ARGS(DIEllipseEdgeEffect, (color, viewMatrix, mode));
     }
 
     virtual ~DIEllipseEdgeEffect() {}
 
     virtual const char* name() const SK_OVERRIDE { return "DIEllipseEdge"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inEllipseOffsets0() const { return fInEllipseOffsets0; }
     const GrAttribute* inEllipseOffsets1() const { return fInEllipseOffsets1; }
 
@@ skipping 126 matching lines @@
                         const GrBatchTracker& t) const SK_OVERRIDE {
         const BatchTracker& mine = m.cast<BatchTracker>();
         const BatchTracker& theirs = t.cast<BatchTracker>();
         return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                        that, theirs.fUsesLocalCoords) &&
                CanCombineOutput(mine.fInputColorType, mine.fColor,
                                 theirs.fInputColorType, theirs.fColor);
     }
 
 private:
-    DIEllipseEdgeEffect(GrColor color, Mode mode) : INHERITED(color) {
+    DIEllipseEdgeEffect(GrColor color, const SkMatrix& viewMatrix, Mode mode)
+        : INHERITED(color, viewMatrix) {
         this->initClassID<DIEllipseEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInEllipseOffsets0 = &this->addVertexAttrib(GrAttribute("inEllipseOffsets0",
                                                                 kVec2f_GrVertexAttribType));
         fInEllipseOffsets1 = &this->addVertexAttrib(GrAttribute("inEllipseOffsets1",
                                                                 kVec2f_GrVertexAttribType));
         fMode = mode;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
@@ skipping 20 matching lines @@
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DIEllipseEdgeEffect);
 
 GrGeometryProcessor* DIEllipseEdgeEffect::TestCreate(SkRandom* random,
                                                      GrContext* context,
                                                      const GrDrawTargetCaps&,
                                                      GrTexture* textures[]) {
-    return DIEllipseEdgeEffect::Create(GrRandomColor(random), (Mode)(random->nextRangeU(0,2)));
+    return DIEllipseEdgeEffect::Create(GrRandomColor(random),
+                                       GrProcessorUnitTest::TestMatrix(random),
+                                       (Mode)(random->nextRangeU(0,2)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrOvalRenderer::reset() {
     SkSafeSetNull(fRRectIndexBuffer);
     SkSafeSetNull(fStrokeRRectIndexBuffer);
 }
 
 bool GrOvalRenderer::drawOval(GrDrawTarget* target,
                               GrDrawState* drawState,
                               GrColor color,
+                              const SkMatrix& viewMatrix,
                               bool useAA,
                               const SkRect& oval,
                               const SkStrokeRec& stroke)
 {
     bool useCoverageAA = useAA &&
         !drawState->getRenderTarget()->isMultisampled() &&
         drawState->canUseFracCoveragePrimProc(color, *target->caps());
 
     if (!useCoverageAA) {
         return false;
     }
 
-    const SkMatrix& vm = drawState->getViewMatrix();
-
     // we can draw circles
-    if (SkScalarNearlyEqual(oval.width(), oval.height())
-        && circle_stays_circle(vm)) {
-        this->drawCircle(target, drawState, color, useCoverageAA, oval, stroke);
+    if (SkScalarNearlyEqual(oval.width(), oval.height()) && circle_stays_circle(viewMatrix)) {
+        this->drawCircle(target, drawState, color, viewMatrix, useCoverageAA, oval, stroke);
     // if we have shader derivative support, render as device-independent
     } else if (target->caps()->shaderDerivativeSupport()) {
-        return this->drawDIEllipse(target, drawState, color, useCoverageAA, oval, stroke);
+        return this->drawDIEllipse(target, drawState, color, viewMatrix, useCoverageAA, oval,
+                                   stroke);
     // otherwise axis-aligned ellipses only
-    } else if (vm.rectStaysRect()) {
-        return this->drawEllipse(target, drawState, color, useCoverageAA, oval, stroke);
+    } else if (viewMatrix.rectStaysRect()) {
+        return this->drawEllipse(target, drawState, color, viewMatrix, useCoverageAA, oval, stroke);
     } else {
         return false;
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrOvalRenderer::drawCircle(GrDrawTarget* target,
                                 GrDrawState* drawState,
                                 GrColor color,
+                                const SkMatrix& viewMatrix,
                                 bool useCoverageAA,
                                 const SkRect& circle,
-                                const SkStrokeRec& stroke)
-{
-    const SkMatrix& vm = drawState->getViewMatrix();
+                                const SkStrokeRec& stroke) {
     SkPoint center = SkPoint::Make(circle.centerX(), circle.centerY());
-    vm.mapPoints(&center, 1);
-    SkScalar radius = vm.mapRadius(SkScalarHalf(circle.width()));
-    SkScalar strokeWidth = vm.mapRadius(stroke.getWidth());
+    viewMatrix.mapPoints(&center, 1);
+    SkScalar radius = viewMatrix.mapRadius(SkScalarHalf(circle.width()));
+    SkScalar strokeWidth = viewMatrix.mapRadius(stroke.getWidth());
 
     SkMatrix invert;
-    if (!vm.invert(&invert)) {
+    if (!viewMatrix.invert(&invert)) {
         return;
     }
 
-    GrDrawState::AutoViewMatrixRestore avmr(drawState);
-
     SkStrokeRec::Style style = stroke.getStyle();
     bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
                         SkStrokeRec::kHairline_Style == style;
     bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
 
     SkScalar innerRadius = 0.0f;
     SkScalar outerRadius = radius;
     SkScalar halfWidth = 0;
     if (hasStroke) {
         if (SkScalarNearlyZero(strokeWidth)) {
             halfWidth = SK_ScalarHalf;
         } else {
             halfWidth = SkScalarHalf(strokeWidth);
         }
 
         outerRadius += halfWidth;
         if (isStrokeOnly) {
             innerRadius = radius - halfWidth;
         }
     }
 
     SkAutoTUnref<GrGeometryProcessor> gp(
-            CircleEdgeEffect::Create(color, isStrokeOnly && innerRadius > 0, invert));
+            CircleEdgeEffect::Create(color, SkMatrix::I(), isStrokeOnly && innerRadius > 0,invert));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, gp->getVertexStride(),  0);
     SkASSERT(gp->getVertexStride() == sizeof(CircleVertex));
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
 
     CircleVertex* verts = reinterpret_cast<CircleVertex*>(geo.vertices());
 
@@ skipping 36 matching lines @@
     target->setIndexSourceToBuffer(fGpu->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrOvalRenderer::drawEllipse(GrDrawTarget* target,
                                  GrDrawState* drawState,
                                  GrColor color,
+                                 const SkMatrix& viewMatrix,
                                  bool useCoverageAA,
                                  const SkRect& ellipse,
-                                 const SkStrokeRec& stroke)
-{
+                                 const SkStrokeRec& stroke) {
 #ifdef SK_DEBUG
     {
         // we should have checked for this previously
-        bool isAxisAlignedEllipse = drawState->getViewMatrix().rectStaysRect();
+        bool isAxisAlignedEllipse = viewMatrix.rectStaysRect();
         SkASSERT(useCoverageAA && isAxisAlignedEllipse);
     }
 #endif
 
     // do any matrix crunching before we reset the draw state for device coords
-    const SkMatrix& vm = drawState->getViewMatrix();
     SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
-    vm.mapPoints(&center, 1);
+    viewMatrix.mapPoints(&center, 1);
     SkScalar ellipseXRadius = SkScalarHalf(ellipse.width());
     SkScalar ellipseYRadius = SkScalarHalf(ellipse.height());
-    SkScalar xRadius = SkScalarAbs(vm[SkMatrix::kMScaleX]*ellipseXRadius +
-                                   vm[SkMatrix::kMSkewY]*ellipseYRadius);
-    SkScalar yRadius = SkScalarAbs(vm[SkMatrix::kMSkewX]*ellipseXRadius +
-                                   vm[SkMatrix::kMScaleY]*ellipseYRadius);
+    SkScalar xRadius = SkScalarAbs(viewMatrix[SkMatrix::kMScaleX]*ellipseXRadius +
+                                   viewMatrix[SkMatrix::kMSkewY]*ellipseYRadius);
+    SkScalar yRadius = SkScalarAbs(viewMatrix[SkMatrix::kMSkewX]*ellipseXRadius +
+                                   viewMatrix[SkMatrix::kMScaleY]*ellipseYRadius);
 
     // do (potentially) anisotropic mapping of stroke
     SkVector scaledStroke;
     SkScalar strokeWidth = stroke.getWidth();
-    scaledStroke.fX = SkScalarAbs(strokeWidth*(vm[SkMatrix::kMScaleX] + vm[SkMatrix::kMSkewY]));
-    scaledStroke.fY = SkScalarAbs(strokeWidth*(vm[SkMatrix::kMSkewX] + vm[SkMatrix::kMScaleY]));
+    scaledStroke.fX = SkScalarAbs(strokeWidth*(viewMatrix[SkMatrix::kMScaleX] +
+                                               viewMatrix[SkMatrix::kMSkewY]));
+    scaledStroke.fY = SkScalarAbs(strokeWidth*(viewMatrix[SkMatrix::kMSkewX] +
+                                               viewMatrix[SkMatrix::kMScaleY]));
 
     SkStrokeRec::Style style = stroke.getStyle();
     bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
                         SkStrokeRec::kHairline_Style == style;
     bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
 
     SkScalar innerXRadius = 0;
     SkScalar innerYRadius = 0;
     if (hasStroke) {
         if (SkScalarNearlyZero(scaledStroke.length())) {
@@ skipping 18 matching lines @@
         if (isStrokeOnly) {
             innerXRadius = xRadius - scaledStroke.fX;
             innerYRadius = yRadius - scaledStroke.fY;
         }
 
         xRadius += scaledStroke.fX;
         yRadius += scaledStroke.fY;
     }
 
     SkMatrix invert;
-    if (!vm.invert(&invert)) {
+    if (!viewMatrix.invert(&invert)) {
         return false;
     }
 
-    GrDrawState::AutoViewMatrixRestore avmr(drawState);
-
     SkAutoTUnref<GrGeometryProcessor> gp(
-            EllipseEdgeEffect::Create(color, isStrokeOnly && innerXRadius > 0 && innerYRadius > 0,
+            EllipseEdgeEffect::Create(color,
+                                      SkMatrix::I(),
+                                      isStrokeOnly && innerXRadius > 0 && innerYRadius > 0,
                                       invert));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, gp->getVertexStride(),  0);
     SkASSERT(gp->getVertexStride() == sizeof(EllipseVertex));
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return false;
     }
 
     EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(geo.vertices());
@@ skipping 40 matching lines @@
     target->setIndexSourceToBuffer(fGpu->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 
     return true;
 }
 
 bool GrOvalRenderer::drawDIEllipse(GrDrawTarget* target,
                                    GrDrawState* drawState,
                                    GrColor color,
+                                   const SkMatrix& viewMatrix,
                                    bool useCoverageAA,
                                    const SkRect& ellipse,
-                                   const SkStrokeRec& stroke)
-{
-    const SkMatrix& vm = drawState->getViewMatrix();
-
+                                   const SkStrokeRec& stroke) {
     SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
     SkScalar xRadius = SkScalarHalf(ellipse.width());
     SkScalar yRadius = SkScalarHalf(ellipse.height());
 
     SkStrokeRec::Style style = stroke.getStyle();
     DIEllipseEdgeEffect::Mode mode = (SkStrokeRec::kStroke_Style == style) ?
                                     DIEllipseEdgeEffect::kStroke :
                                     (SkStrokeRec::kHairline_Style == style) ?
                                     DIEllipseEdgeEffect::kHairline : DIEllipseEdgeEffect::kFill;
 
@@ skipping 29 matching lines @@
         xRadius += strokeWidth;
         yRadius += strokeWidth;
     }
     if (DIEllipseEdgeEffect::kStroke == mode) {
         mode = (innerXRadius > 0 && innerYRadius > 0) ? DIEllipseEdgeEffect::kStroke :
                                                         DIEllipseEdgeEffect::kFill;
     }
     SkScalar innerRatioX = SkScalarDiv(xRadius, innerXRadius);
     SkScalar innerRatioY = SkScalarDiv(yRadius, innerYRadius);
 
-    SkAutoTUnref<GrGeometryProcessor> gp(DIEllipseEdgeEffect::Create(color, mode));
+    SkAutoTUnref<GrGeometryProcessor> gp(DIEllipseEdgeEffect::Create(color, viewMatrix, mode));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, gp->getVertexStride(),  0);
     SkASSERT(gp->getVertexStride() == sizeof(DIEllipseVertex));
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return false;
     }
 
     DIEllipseVertex* verts = reinterpret_cast<DIEllipseVertex*>(geo.vertices());
 
     // This expands the outer rect so that after CTM we end up with a half-pixel border
-    SkScalar a = vm[SkMatrix::kMScaleX];
-    SkScalar b = vm[SkMatrix::kMSkewX];
-    SkScalar c = vm[SkMatrix::kMSkewY];
-    SkScalar d = vm[SkMatrix::kMScaleY];
+    SkScalar a = viewMatrix[SkMatrix::kMScaleX];
+    SkScalar b = viewMatrix[SkMatrix::kMSkewX];
+    SkScalar c = viewMatrix[SkMatrix::kMSkewY];
+    SkScalar d = viewMatrix[SkMatrix::kMScaleY];
     SkScalar geoDx = SkScalarDiv(SK_ScalarHalf, SkScalarSqrt(a*a + c*c));
     SkScalar geoDy = SkScalarDiv(SK_ScalarHalf, SkScalarSqrt(b*b + d*d));
     // This adjusts the "radius" to include the half-pixel border
     SkScalar offsetDx = SkScalarDiv(geoDx, xRadius);
     SkScalar offsetDy = SkScalarDiv(geoDy, yRadius);
 
     SkRect bounds = SkRect::MakeLTRB(
         center.fX - xRadius - geoDx,
         center.fY - yRadius - geoDy,
         center.fX + xRadius + geoDx,
@@ skipping 64 matching lines @@
                                                                  kNumRRectsInIndexBuffer,
                                                                  kVertsPerRRect);
         }
         return fRRectIndexBuffer;
     }
 }
 
 bool GrOvalRenderer::drawDRRect(GrDrawTarget* target,
                                 GrDrawState* drawState,
                                 GrColor color,
+                                const SkMatrix& viewMatrix,
                                 bool useAA,
                                 const SkRRect& origOuter,
                                 const SkRRect& origInner) {
     bool applyAA = useAA &&
                    !drawState->getRenderTarget()->isMultisampled() &&
                    drawState->canUseFracCoveragePrimProc(color, *target->caps());
     GrDrawState::AutoRestoreEffects are;
     if (!origInner.isEmpty()) {
         SkTCopyOnFirstWrite<SkRRect> inner(origInner);
-        if (!drawState->getViewMatrix().isIdentity()) {
-            if (!origInner.transform(drawState->getViewMatrix(), inner.writable())) {
+        if (!viewMatrix.isIdentity()) {
+            if (!origInner.transform(viewMatrix, inner.writable())) {
                 return false;
             }
         }
         GrPrimitiveEdgeType edgeType = applyAA ?
                 kInverseFillAA_GrProcessorEdgeType :
                 kInverseFillBW_GrProcessorEdgeType;
         // TODO this needs to be a geometry processor
         GrFragmentProcessor* fp = GrRRectEffect::Create(edgeType, *inner);
         if (NULL == fp) {
             return false;
         }
         are.set(drawState);
         drawState->addCoverageProcessor(fp)->unref();
     }
 
     SkStrokeRec fillRec(SkStrokeRec::kFill_InitStyle);
-    if (this->drawRRect(target, drawState, color, useAA, origOuter, fillRec)) {
+    if (this->drawRRect(target, drawState, color, viewMatrix, useAA, origOuter, fillRec)) {
         return true;
     }
 
     SkASSERT(!origOuter.isEmpty());
     SkTCopyOnFirstWrite<SkRRect> outer(origOuter);
-    if (!drawState->getViewMatrix().isIdentity()) {
-        if (!origOuter.transform(drawState->getViewMatrix(), outer.writable())) {
+    if (!viewMatrix.isIdentity()) {
+        if (!origOuter.transform(viewMatrix, outer.writable())) {
             return false;
         }
     }
     GrPrimitiveEdgeType edgeType = applyAA ? kFillAA_GrProcessorEdgeType :
                                           kFillBW_GrProcessorEdgeType;
     GrFragmentProcessor* effect = GrRRectEffect::Create(edgeType, *outer);
     if (NULL == effect) {
         return false;
     }
     if (!are.isSet()) {
         are.set(drawState);
     }
 
     SkMatrix invert;
-    if (!drawState->getViewMatrix().invert(&invert)) {
+    if (!viewMatrix.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->drawRect(drawState, color, bounds, NULL, &invert);
+    target->drawRect(drawState, color, SkMatrix::I(), bounds, NULL, &invert);
     return true;
 }
 
 bool GrOvalRenderer::drawRRect(GrDrawTarget* target,
                                GrDrawState* drawState,
                                GrColor color,
+                               const SkMatrix& viewMatrix,
                                bool useAA,
                                const SkRRect& rrect,
                                const SkStrokeRec& stroke) {
     if (rrect.isOval()) {
-        return this->drawOval(target, drawState, color, useAA, rrect.getBounds(), stroke);
+        return this->drawOval(target, drawState, color, viewMatrix, useAA, rrect.getBounds(),
+                              stroke);
     }
 
     bool useCoverageAA = useAA &&
         !drawState->getRenderTarget()->isMultisampled() &&
         drawState->canUseFracCoveragePrimProc(color, *target->caps());
 
     // only anti-aliased rrects for now
     if (!useCoverageAA) {
         return false;
     }
 
-    const SkMatrix& vm = drawState->getViewMatrix();
-
-    if (!vm.rectStaysRect() || !rrect.isSimple()) {
+    if (!viewMatrix.rectStaysRect() || !rrect.isSimple()) {
         return false;
     }
 
     // do any matrix crunching before we reset the draw state for device coords
     const SkRect& rrectBounds = rrect.getBounds();
     SkRect bounds;
-    vm.mapRect(&bounds, rrectBounds);
+    viewMatrix.mapRect(&bounds, rrectBounds);
 
     SkVector radii = rrect.getSimpleRadii();
-    SkScalar xRadius = SkScalarAbs(vm[SkMatrix::kMScaleX]*radii.fX +
-                                   vm[SkMatrix::kMSkewY]*radii.fY);
-    SkScalar yRadius = SkScalarAbs(vm[SkMatrix::kMSkewX]*radii.fX +
-                                   vm[SkMatrix::kMScaleY]*radii.fY);
+    SkScalar xRadius = SkScalarAbs(viewMatrix[SkMatrix::kMScaleX]*radii.fX +
+                                   viewMatrix[SkMatrix::kMSkewY]*radii.fY);
+    SkScalar yRadius = SkScalarAbs(viewMatrix[SkMatrix::kMSkewX]*radii.fX +
+                                   viewMatrix[SkMatrix::kMScaleY]*radii.fY);
 
     SkStrokeRec::Style style = stroke.getStyle();
 
     // do (potentially) anisotropic mapping of stroke
     SkVector scaledStroke;
     SkScalar strokeWidth = stroke.getWidth();
 
     bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
                         SkStrokeRec::kHairline_Style == style;
     bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
 
     if (hasStroke) {
         if (SkStrokeRec::kHairline_Style == style) {
             scaledStroke.set(1, 1);
         } else {
-            scaledStroke.fX = SkScalarAbs(strokeWidth*(vm[SkMatrix::kMScaleX] +
-                                                       vm[SkMatrix::kMSkewY]));
-            scaledStroke.fY = SkScalarAbs(strokeWidth*(vm[SkMatrix::kMSkewX] +
-                                                       vm[SkMatrix::kMScaleY]));
+            scaledStroke.fX = SkScalarAbs(strokeWidth*(viewMatrix[SkMatrix::kMScaleX] +
+                                                       viewMatrix[SkMatrix::kMSkewY]));
+            scaledStroke.fY = SkScalarAbs(strokeWidth*(viewMatrix[SkMatrix::kMSkewX] +
+                                                       viewMatrix[SkMatrix::kMScaleY]));
         }
 
         // if half of strokewidth is greater than radius, we don't handle that right now
         if (SK_ScalarHalf*scaledStroke.fX > xRadius || SK_ScalarHalf*scaledStroke.fY > yRadius) {
             return false;
         }
     }
 
     // The way the effect interpolates the offset-to-ellipse/circle-center attribute only works on
     // the interior of the rrect if the radii are >= 0.5. Otherwise, the inner rect of the nine-
     // patch will have fractional coverage. This only matters when the interior is actually filled.
     // We could consider falling back to rect rendering here, since a tiny radius is
     // indistinguishable from a square corner.
     if (!isStrokeOnly && (SK_ScalarHalf > xRadius || SK_ScalarHalf > yRadius)) {
         return false;
     }
 
     // reset to device coordinates
     SkMatrix invert;
-    if (!vm.invert(&invert)) {
+    if (!viewMatrix.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");
         return false;
     }
 
     // if the corners are circles, use the circle renderer
     if ((!hasStroke || scaledStroke.fX == scaledStroke.fY) && xRadius == yRadius) {
         SkScalar innerRadius = 0.0f;
         SkScalar outerRadius = xRadius;
         SkScalar halfWidth = 0;
         if (hasStroke) {
             if (SkScalarNearlyZero(scaledStroke.fX)) {
                 halfWidth = SK_ScalarHalf;
             } else {
                 halfWidth = SkScalarHalf(scaledStroke.fX);
             }
 
             if (isStrokeOnly) {
                 innerRadius = xRadius - halfWidth;
             }
             outerRadius += halfWidth;
             bounds.outset(halfWidth, halfWidth);
         }
 
         isStrokeOnly = (isStrokeOnly && innerRadius >= 0);
 
-        SkAutoTUnref<GrGeometryProcessor> effect(CircleEdgeEffect::Create(color, isStrokeOnly,
+        SkAutoTUnref<GrGeometryProcessor> effect(CircleEdgeEffect::Create(color,
+                                                                          SkMatrix::I(),
+                                                                          isStrokeOnly,
                                                                           invert));
 
         GrDrawTarget::AutoReleaseGeometry geo(target, 16, effect->getVertexStride(),  0);
         SkASSERT(effect->getVertexStride() == sizeof(CircleVertex));
         if (!geo.succeeded()) {
             SkDebugf("Failed to get space for vertices!\n");
             return false;
         }
         CircleVertex* verts = reinterpret_cast<CircleVertex*>(geo.vertices());
 
@@ skipping 79 matching lines @@
                 innerYRadius = yRadius - scaledStroke.fY;
             }
 
             xRadius += scaledStroke.fX;
             yRadius += scaledStroke.fY;
             bounds.outset(scaledStroke.fX, scaledStroke.fY);
         }
 
         isStrokeOnly = (isStrokeOnly && innerXRadius >= 0 && innerYRadius >= 0);
 
-        SkAutoTUnref<GrGeometryProcessor> effect(EllipseEdgeEffect::Create(color, isStrokeOnly,
+        SkAutoTUnref<GrGeometryProcessor> effect(EllipseEdgeEffect::Create(color,
+                                                                           SkMatrix::I(),
+                                                                           isStrokeOnly,
                                                                            invert));
 
         GrDrawTarget::AutoReleaseGeometry geo(target, 16, effect->getVertexStride(),  0);
         SkASSERT(effect->getVertexStride() == sizeof(EllipseVertex));
         if (!geo.succeeded()) {
             SkDebugf("Failed to get space for vertices!\n");
             return false;
         }
 
         EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(geo.vertices());
@@ skipping 54 matching lines @@
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
         target->drawIndexedInstances(drawState, effect, kTriangles_GrPrimitiveType, 1, 16, indexCnt,
                                      &bounds);
     }
 
     target->resetIndexSource();
     return true;
 }