Eliminate special case nvpr batch handling

src/gpu/gl/GrGLPathRendering.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLPathRendering.h"
 #include "gl/GrGLUtil.h"
 #include "gl/GrGLGpu.h"
@@ skipping 52 matching lines @@
         SkASSERT(!SkScalarIsNaN(SkFloatToScalar(floats[i])));
     }
 }
 #endif
 
 static GrGLenum gr_stencil_op_to_gl_path_rendering_fill_mode(GrStencilOp op) {
     switch (op) {
         default:
             SkFAIL("Unexpected path fill.");
             /* fallthrough */;
-        case GrStencilOp::kIncClamp:
+        case GrStencilOp::kIncWrap:
             return GR_GL_COUNT_UP;
         case GrStencilOp::kInvert:
             return GR_GL_INVERT;
     }
 }
 
 GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
     : GrPathRendering(gpu)
     , fPreallocatedPathCount(0) {
     const GrGLInterface* glInterface = gpu->glInterface();
@@ skipping 56 matching lines @@
     if (glPath->shouldFill()) {
         GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
     }
     if (glPath->shouldStroke()) {
         GL_CALL(StencilStrokePath(glPath->pathID(), 0xffff, writeMask));
     }
 }
 
 void GrGLPathRendering::onDrawPath(const GrPipeline& pipeline,
                                    const GrPrimitiveProcessor& primProc,
-                                   const GrStencilSettings& stencil,
+                                   const GrStencilSettings& stencilPassSettings,
                                    const GrPath* path) {
     if (!this->gpu()->flushGLState(pipeline, primProc)) {
         return;
     }
     const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
 
-    this->flushPathStencilSettings(stencil);
+    this->flushPathStencilSettings(stencilPassSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
     GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;
 
     if (glPath->shouldStroke()) {
         if (glPath->shouldFill()) {
             GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
         }
         GL_CALL(StencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask,
                                            GR_GL_BOUNDING_BOX));
     } else {
         GL_CALL(StencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask,
                                          GR_GL_BOUNDING_BOX));
     }
 }
 
 void GrGLPathRendering::onDrawPaths(const GrPipeline& pipeline,
                                     const GrPrimitiveProcessor& primProc,
-                                    const GrStencilSettings& stencil, const GrPathRange* pathRange,
-                                    const void* indices, PathIndexType indexType,
-                                    const float transformValues[], PathTransformType transformType,
-                                    int count) {
+                                    const GrStencilSettings& stencilPassSettings,
+                                    const GrPathRange* pathRange, const void* indices,
+                                    PathIndexType indexType, const float transformValues[],
+                                    PathTransformType transformType, int count) {
     SkDEBUGCODE(verify_floats(transformValues, gXformType2ComponentCount[transformType] * count));
 
     if (!this->gpu()->flushGLState(pipeline, primProc)) {
         return;
     }
-    this->flushPathStencilSettings(stencil);
+    this->flushPathStencilSettings(stencilPassSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
 
     const GrGLPathRange* glPathRange = static_cast<const GrGLPathRange*>(pathRange);
 
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
     GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;
 
     if (glPathRange->shouldStroke()) {
@@ skipping 132 matching lines @@
             testMask != fHWPathStencilSettings.front().fTestMask) {
             GL_CALL(PathStencilFunc(GrToGLStencilFunc(test), ref, testMask));
         }
         fHWPathStencilSettings = stencilSettings;
     }
 }
 
 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }