Revert of r13384 (Stateful PathRenderer implementation)

src/gpu/GrDefaultPathRenderer.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 "GrDefaultPathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 145 matching lines @@
     return true;
 #else
     if (!stroke.isHairlineStyle() && !path.isInverseFillType()) {
         return path.isConvex();
     }
     return false;
 #endif
 }
 
 GrPathRenderer::StencilSupport GrDefaultPathRenderer::onGetStencilSupport(
+                                                            const SkPath& path,
                                                             const SkStrokeRec& stroke,
                                                             const GrDrawTarget*) const {
-    if (single_pass_path(this->path(), stroke)) {
+    if (single_pass_path(path, stroke)) {
         return GrPathRenderer::kNoRestriction_StencilSupport;
     } else {
         return GrPathRenderer::kStencilOnly_StencilSupport;
     }
 }
 
 static inline void append_countour_edge_indices(bool hairLine,
                                                 uint16_t fanCenterIdx,
                                                 uint16_t edgeV0Idx,
                                                 uint16_t** indices) {
@@ skipping 138 matching lines @@
     SkASSERT((vert - base) <= maxPts);
     SkASSERT((idx - idxBase) <= maxIdxs);
 
     *vertexCnt = static_cast<int>(vert - base);
     *indexCnt = static_cast<int>(idx - idxBase);
 
     }
     return true;
 }
 
-bool GrDefaultPathRenderer::internalDrawPath(const SkStrokeRec& origStroke,
+bool GrDefaultPathRenderer::internalDrawPath(const SkPath& path,
+                                             const SkStrokeRec& origStroke,
                                              GrDrawTarget* target,
                                              bool stencilOnly) {
 
     SkMatrix viewM = target->getDrawState().getViewMatrix();
     SkTCopyOnFirstWrite<SkStrokeRec> stroke(origStroke);
 
     SkScalar hairlineCoverage;
     if (IsStrokeHairlineOrEquivalent(*stroke, target->getDrawState().getViewMatrix(),
                                      &hairlineCoverage)) {
         uint8_t newCoverage = SkScalarRoundToInt(hairlineCoverage *
                                                  target->getDrawState().getCoverage());
         target->drawState()->setCoverage(newCoverage);
 
         if (!stroke->isHairlineStyle()) {
             stroke.writable()->setHairlineStyle();
         }
     }
 
     SkScalar tol = SK_Scalar1;
-    tol = GrPathUtils::scaleToleranceToSrc(tol, viewM, this->path().getBounds());
+    tol = GrPathUtils::scaleToleranceToSrc(tol, viewM, path.getBounds());
 
     int vertexCnt;
     int indexCnt;
     GrPrimitiveType primType;
     GrDrawTarget::AutoReleaseGeometry arg;
-    if (!this->createGeom(this->path(),
+    if (!this->createGeom(path,
                           *stroke,
                           tol,
                           target,
                           &primType,
                           &vertexCnt,
                           &indexCnt,
                           &arg)) {
         return false;
     }
 
@@ skipping 13 matching lines @@
     if (stroke->isHairlineStyle()) {
         passCount = 1;
         if (stencilOnly) {
             passes[0] = &gDirectToStencil;
         } else {
             passes[0] = NULL;
         }
         lastPassIsBounds = false;
         drawFace[0] = GrDrawState::kBoth_DrawFace;
     } else {
-        if (single_pass_path(this->path(), *stroke)) {
+        if (single_pass_path(path, *stroke)) {
             passCount = 1;
             if (stencilOnly) {
                 passes[0] = &gDirectToStencil;
             } else {
                 passes[0] = NULL;
             }
             drawFace[0] = GrDrawState::kBoth_DrawFace;
             lastPassIsBounds = false;
         } else {
-            switch (this->path().getFillType()) {
+            switch (path.getFillType()) {
                 case SkPath::kInverseEvenOdd_FillType:
                     reverse = true;
                     // fallthrough
                 case SkPath::kEvenOdd_FillType:
                     passes[0] = &gEOStencilPass;
                     if (stencilOnly) {
                         passCount = 1;
                         lastPassIsBounds = false;
                     } else {
                         passCount = 2;
@@ skipping 46 matching lines @@
                     }
                     break;
                 default:
                     SkDEBUGFAIL("Unknown path fFill!");
                     return false;
             }
         }
     }
 
     SkRect devBounds;
-    GetPathDevBounds(this->path(), drawState->getRenderTarget(), viewM, &devBounds);
+    GetPathDevBounds(path, drawState->getRenderTarget(), viewM, &devBounds);
 
     for (int p = 0; p < passCount; ++p) {
         drawState->setDrawFace(drawFace[p]);
         if (NULL != passes[p]) {
             *drawState->stencil() = *passes[p];
         }
 
         if (lastPassIsBounds && (p == passCount-1)) {
             if (!colorWritesWereDisabled) {
                 drawState->disableState(GrDrawState::kNoColorWrites_StateBit);
             }
             SkRect bounds;
             GrDrawState::AutoViewMatrixRestore avmr;
             if (reverse) {
                 SkASSERT(NULL != drawState->getRenderTarget());
                 // draw over the dev bounds (which will be the whole dst surface for inv fill).
                 bounds = devBounds;
                 SkMatrix vmi;
                 // mapRect through persp matrix may not be correct
                 if (!drawState->getViewMatrix().hasPerspective() &&
                     drawState->getViewInverse(&vmi)) {
                     vmi.mapRect(&bounds);
                 } else {
                     avmr.setIdentity(drawState);
                 }
             } else {
-                bounds = this->path().getBounds();
+                bounds = path.getBounds();
             }
             GrDrawTarget::AutoGeometryAndStatePush agasp(target, GrDrawTarget::kPreserve_ASRInit);
             target->drawSimpleRect(bounds, NULL);
         } else {
             if (passCount > 1) {
                 drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
             }
             if (indexCnt) {
                 target->drawIndexed(primType, 0, 0,
                                     vertexCnt, indexCnt, &devBounds);
             } else {
                 target->drawNonIndexed(primType, 0, vertexCnt, &devBounds);
             }
         }
     }
     return true;
 }
 
-bool GrDefaultPathRenderer::canDrawPath(const SkStrokeRec& stroke,
+bool GrDefaultPathRenderer::canDrawPath(const SkPath& path,
+                                        const SkStrokeRec& stroke,
                                         const GrDrawTarget* target,
                                         bool antiAlias) const {
     // this class can draw any path with any fill but doesn't do any anti-aliasing.
 
     return !antiAlias &&
         (stroke.isFillStyle() ||
          IsStrokeHairlineOrEquivalent(stroke, target->getDrawState().getViewMatrix(), NULL));
 }
 
-bool GrDefaultPathRenderer::onDrawPath(const SkStrokeRec& stroke,
+bool GrDefaultPathRenderer::onDrawPath(const SkPath& path,
+                                       const SkStrokeRec& stroke,
                                        GrDrawTarget* target,
                                        bool antiAlias) {
-    return this->internalDrawPath(stroke, target, false);
+    return this->internalDrawPath(path,
+                                  stroke,
+                                  target,
+                                  false);
 }
 
-void GrDefaultPathRenderer::onStencilPath(const SkStrokeRec& stroke,
+void GrDefaultPathRenderer::onStencilPath(const SkPath& path,
+                                          const SkStrokeRec& stroke,
                                           GrDrawTarget* target) {
-    SkASSERT(SkPath::kInverseEvenOdd_FillType != this->path().getFillType());
-    SkASSERT(SkPath::kInverseWinding_FillType != this->path().getFillType());
-    this->internalDrawPath(stroke, target, true);
+    SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
+    SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
+    this->internalDrawPath(path, stroke, target, true);
 }