Move ViewMatrix off of drawstate

src/gpu/GrAAConvexPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexPathRenderer.h"
 
@@ skipping 609 matching lines @@
         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:
     QuadEdgeEffect(GrColor color, const SkMatrix& localMatrix)
-        : INHERITED(color, false, localMatrix) {
+        : INHERITED(color, SkMatrix::I(), localMatrix) {
         this->initClassID<QuadEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInQuadEdge = &this->addVertexAttrib(GrAttribute("inQuadEdge", kVec4f_GrVertexAttribType));
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         return true;
     }
 
     virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
@@ skipping 23 matching lines @@
     // Doesn't work without derivative instructions.
     return caps.shaderDerivativeSupport() ?
            QuadEdgeEffect::Create(GrRandomColor(random),
                                   GrProcessorUnitTest::TestMatrix(random)) : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAAConvexPathRenderer::canDrawPath(const GrDrawTarget* target,
                                          const GrDrawState*,
+                                         const SkMatrix& viewMatrix,
                                          const SkPath& path,
                                          const SkStrokeRec& stroke,
                                          bool antiAlias) const {
     return (target->caps()->shaderDerivativeSupport() && antiAlias &&
             stroke.isFillStyle() && !path.isInverseFillType() && path.isConvex());
 }
 
 bool GrAAConvexPathRenderer::onDrawPath(GrDrawTarget* target,
                                         GrDrawState* drawState,
                                         GrColor color,
+                                        const SkMatrix& vm,
                                         const SkPath& origPath,
                                         const SkStrokeRec&,
                                         bool antiAlias) {
 
     const SkPath* path = &origPath;
     if (path->isEmpty()) {
         return true;
     }
 
-    SkMatrix viewMatrix = drawState->getViewMatrix();
+    SkMatrix viewMatrix = vm;
     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.
     SkPath tmpPath;
     if (viewMatrix.hasPerspective()) {
         origPath.transform(viewMatrix, &tmpPath);
         path = &tmpPath;
         viewMatrix = SkMatrix::I();
     }
 
@@ skipping 53 matching lines @@
                             vOffset,  // start vertex
                             0,        // start index
                             draw.fVertexCnt,
                             draw.fIndexCnt,
                             &devBounds);
         vOffset += draw.fVertexCnt;
     }
 
     return true;
 }