Remove coordchanges from drawstate

src/gpu/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 814 matching lines @@
     PREALLOC_PTARRAY(128) lines;
     PREALLOC_PTARRAY(128) quads;
     PREALLOC_PTARRAY(128) conics;
     IntArray qSubdivs;
     FloatArray cWeights;
     quadCnt = generate_lines_and_quads(path, drawState->getViewMatrix(), devClipBounds,
                                        &lines, &quads, &conics, &qSubdivs, &cWeights);
     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,
                                   newCoverage,
                                   gp->getVertexStride(),
                                   &arg,
                                   &devBounds,
                                   path,
                                   lines,
                                   lineCnt)) {
             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));
 
         {
             target->setIndexSourceToBuffer(fLinesIndexBuffer);
             int lines = 0;
             while (lines < lineCnt) {
                 int n = SkTMin(lineCnt - lines, kLineSegsNumInIdxBuffer);
                 target->drawIndexed(drawState,
@@ skipping 22 matching lines @@
                                     quads,
                                     quadCnt,
                                     conics,
                                     conicCnt,
                                     qSubdivs,
                                     cWeights,
                                     sizeof(BezierVertex))) {
             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));
 
         if (quadCnt > 0) {
             SkAutoTUnref<GrGeometryProcessor> hairQuadProcessor(
                     GrQuadEffect::Create(color,
                                          kHairlineAA_GrProcessorEdgeType,
                                          *target->caps(),
+                                         invert,
                                          newCoverage));
             SkASSERT(hairQuadProcessor);
             GrDrawState::AutoRestoreEffects are(drawState);
             target->setIndexSourceToBuffer(fQuadsIndexBuffer);
 
             int quads = 0;
             while (quads < quadCnt) {
                 int n = SkTMin(quadCnt - quads, kQuadsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     hairQuadProcessor,
                                     kTriangles_GrPrimitiveType,
                                     kQuadNumVertices*quads,               // startV
                                     0,                                    // startI
                                     kQuadNumVertices*n,                   // vCount
                                     kIdxsPerQuad*n,                       // iCount
                                     &devBounds);
                 quads += n;
             }
         }
 
         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);
 
             int conics = 0;
             while (conics < conicCnt) {
                 int n = SkTMin(conicCnt - conics, kQuadsNumInIdxBuffer);
                 target->drawIndexed(drawState,
                                     hairConicProcessor,
                                     kTriangles_GrPrimitiveType,
                                     kQuadNumVertices*(quadCnt + conics),  // startV
                                     0,                                    // startI
                                     kQuadNumVertices*n,                   // vCount
                                     kIdxsPerQuad*n,                       // iCount
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }