Simplify GrGLPathRendering interface

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/GrGLInterface.h"
 #include "gl/GrGLNameAllocator.h"
@@ skipping 28 matching lines @@
         default:
             SkFAIL("Unexpected path fill.");
             /* fallthrough */;
         case kIncClamp_StencilOp:
             return GR_GL_COUNT_UP;
         case kInvert_StencilOp:
             return GR_GL_INVERT;
     }
 }
 
-class GrGLPathRenderingV12 : public GrGLPathRendering {
-public:
-    GrGLPathRenderingV12(GrGpuGL* gpu, const GrGLInterface* glInterface)
-        : GrGLPathRendering(gpu, glInterface) {
-    }
-
-    virtual GrGLvoid stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode,
-                                              GrGLuint mask, GrGLenum coverMode) SK_OVERRIDE;
-    virtual GrGLvoid stencilThenCoverStrokePath(GrGLuint path, GrGLint reference,
-                                                GrGLuint mask, GrGLenum coverMode) SK_OVERRIDE;
-    virtual GrGLvoid stencilThenCoverFillPathInstanced(
-                         GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-                         GrGLuint pathBase, GrGLenum fillMode, GrGLuint mask, GrGLenum coverMode,
-                         GrGLenum transformType, const GrGLfloat *transformValues) SK_OVERRIDE;
-    virtual GrGLvoid stencilThenCoverStrokePathInstanced(
-                         GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-                         GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode,
-                         GrGLenum transformType, const GrGLfloat *transformValues) SK_OVERRIDE;
-};
-
-class GrGLPathRenderingV13 : public GrGLPathRenderingV12 {
-public:
-    GrGLPathRenderingV13(GrGpuGL* gpu, const GrGLInterface* glInterface)
-        : GrGLPathRenderingV12(gpu, glInterface) {
-        fCaps.fragmentInputGenSupport = true;
-    }
-
-    virtual GrGLvoid programPathFragmentInputGen(GrGLuint program, GrGLint location,
-                                                 GrGLenum genMode, GrGLint components,
-                                                 const GrGLfloat *coeffs) SK_OVERRIDE;
-};
-
-
-GrGLPathRendering* GrGLPathRendering::Create(GrGpuGL* gpu, const GrGLInterface* glInterface) {
-    if (NULL == glInterface->fFunctions.fStencilThenCoverFillPath ||
-        NULL == glInterface->fFunctions.fStencilThenCoverStrokePath ||
-        NULL == glInterface->fFunctions.fStencilThenCoverFillPathInstanced ||
-        NULL == glInterface->fFunctions.fStencilThenCoverStrokePathInstanced) {
-        return new GrGLPathRendering(gpu, glInterface);
-    }
-
-    if (NULL == glInterface->fFunctions.fProgramPathFragmentInputGen) {
-        return new GrGLPathRenderingV12(gpu, glInterface);
-    }
-
-    return new GrGLPathRenderingV13(gpu, glInterface);
-}
-
 GrGLPathRendering::GrGLPathRendering(GrGpuGL* gpu, const GrGLInterface* glInterface)
     : fGpu(gpu),
       fGLInterface(SkRef(glInterface)) {
-    memset(&fCaps, 0, sizeof(fCaps));
+    fCaps.thenFunctionsSupport =
+        NULL != glInterface->fFunctions.fStencilThenCoverFillPath &&
+        NULL != glInterface->fFunctions.fStencilThenCoverStrokePath &&
+        NULL != glInterface->fFunctions.fStencilThenCoverFillPathInstanced &&
+        NULL != glInterface->fFunctions.fStencilThenCoverStrokePathInstanced;
+    fCaps.fragmentInputGenSupport =
+        NULL != glInterface->fFunctions.fProgramPathFragmentInputGen;
     fHWPathTexGenSettings.reset(fGpu->glCaps().maxFixedFunctionTextureCoords());
 }
 
 GrGLPathRendering::~GrGLPathRendering() {
 }
 
 void GrGLPathRendering::abandonGpuResources() {
     fPathNameAllocator.reset(NULL);
 }
 
 void GrGLPathRendering::onResetContext() {
     fHWProjectionMatrixState.invalidate();
     // we don't use the model view matrix.
     GL_CALL(MatrixLoadIdentity(GR_GL_MODELVIEW));
 
     for (int i = 0; i < fGpu->glCaps().maxFixedFunctionTextureCoords(); ++i) {
-        this->pathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL);
+        GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
         fHWPathTexGenSettings[i].fMode = GR_GL_NONE;
         fHWPathTexGenSettings[i].fNumComponents = 0;
     }
     fHWActivePathTexGenSets = 0;
     fHWPathStencilSettings.invalidate();
 }
 
 GrPath* GrGLPathRendering::createPath(const SkPath& inPath, const SkStrokeRec& stroke) {
     return SkNEW_ARGS(GrGLPath, (fGpu, inPath, stroke));
 }
 
 GrPathRange* GrGLPathRendering::createPathRange(size_t size, const SkStrokeRec& stroke) {
     return SkNEW_ARGS(GrGLPathRange, (fGpu, size, stroke));
 }
 
-void GrGLPathRendering::enablePathTexGen(int unitIdx, PathTexGenComponents components,
-                                         const GrGLfloat* coefficients) {
-    SkASSERT(components >= kS_PathTexGenComponents &&
-             components <= kSTR_PathTexGenComponents);
-    SkASSERT(fGpu->glCaps().maxFixedFunctionTextureCoords() >= unitIdx);
-
-    if (GR_GL_OBJECT_LINEAR == fHWPathTexGenSettings[unitIdx].fMode &&
-        components == fHWPathTexGenSettings[unitIdx].fNumComponents &&
-        !memcmp(coefficients, fHWPathTexGenSettings[unitIdx].fCoefficients,
-                3 * components * sizeof(GrGLfloat))) {
-        return;
-    }
-
-    fGpu->setTextureUnit(unitIdx);
-
-    fHWPathTexGenSettings[unitIdx].fNumComponents = components;
-    this->pathTexGen(GR_GL_TEXTURE0 + unitIdx, GR_GL_OBJECT_LINEAR, components, coefficients);
-
-    memcpy(fHWPathTexGenSettings[unitIdx].fCoefficients, coefficients,
-           3 * components * sizeof(GrGLfloat));
-}
-
-void GrGLPathRendering::enablePathTexGen(int unitIdx, PathTexGenComponents components,
-                                         const SkMatrix& matrix) {
-    GrGLfloat coefficients[3 * 3];
-    SkASSERT(components >= kS_PathTexGenComponents &&
-             components <= kSTR_PathTexGenComponents);
-
-    coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
-    coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
-    coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);
-
-    if (components >= kST_PathTexGenComponents) {
-        coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
-        coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]);
-        coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]);
-    }
-
-    if (components >= kSTR_PathTexGenComponents) {
-        coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]);
-        coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]);
-        coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]);
-    }
-
-    this->enablePathTexGen(unitIdx, components, coefficients);
-}
-
-void GrGLPathRendering::flushPathTexGenSettings(int numUsedTexCoordSets) {
-    SkASSERT(fGpu->glCaps().maxFixedFunctionTextureCoords() >= numUsedTexCoordSets);
-
-    // Only write the inactive path tex gens, since active path tex gens were
-    // written when they were enabled.
-
-    SkDEBUGCODE(
-        for (int i = 0; i < numUsedTexCoordSets; i++) {
-            SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents);
-        }
-    );
-
-    for (int i = numUsedTexCoordSets; i < fHWActivePathTexGenSets; i++) {
-        SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents);
-
-        fGpu->setTextureUnit(i);
-        GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
-        fHWPathTexGenSettings[i].fNumComponents = 0;
-    }
-
-    fHWActivePathTexGenSets = numUsedTexCoordSets;
-}
-
 void GrGLPathRendering::stencilPath(const GrPath* path, SkPath::FillType fill) {
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget());
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget()->getStencilBuffer());
 
     this->flushPathStencilSettings(fill);
 
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
-    this->stencilFillPath(id, fillMode, writeMask);
+    GL_CALL(StencilFillPath(id, fillMode, writeMask));
 }
 
 void GrGLPathRendering::drawPath(const GrPath* path, SkPath::FillType fill) {
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget());
     SkASSERT(NULL != fGpu->drawState()->getRenderTarget()->getStencilBuffer());
     SkASSERT(!fGpu->fCurrentProgram->hasVertexShader());
 
     this->flushPathStencilSettings(fill);
     const SkStrokeRec& stroke = path->getStroke();
 
     SkPath::FillType nonInvertedFill = SkPath::ConvertToNonInverseFillType(fill);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (nonInvertedFill == fill) {
         if (stroke.needToApply()) {
             if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-                this->stencilFillPath(id, fillMode, writeMask);
+                GL_CALL(StencilFillPath(id, fillMode, writeMask));
             }
             this->stencilThenCoverStrokePath(id, 0xffff, writeMask, GR_GL_BOUNDING_BOX);
         } else {
             this->stencilThenCoverFillPath(id, fillMode, writeMask, GR_GL_BOUNDING_BOX);
         }
     } else {
         if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-            this->stencilFillPath(id, fillMode, writeMask);
+            GL_CALL(StencilFillPath(id, fillMode, writeMask));
         }
         if (stroke.needToApply()) {
-            this->stencilStrokePath(id, 0xffff, writeMask);
+            GL_CALL(StencilStrokePath(id, 0xffff, writeMask));
         }
 
         GrDrawState* drawState = fGpu->drawState();
         GrDrawState::AutoViewMatrixRestore avmr;
         SkRect bounds = SkRect::MakeLTRB(0, 0,
                                          SkIntToScalar(drawState->getRenderTarget()->width()),
                                          SkIntToScalar(drawState->getRenderTarget()->height()));
         SkMatrix vmi;
         // mapRect through persp matrix may not be correct
         if (!drawState->getViewMatrix().hasPerspective() && drawState->getViewInverse(&vmi)) {
@@ skipping 29 matching lines @@
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(
             fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask =
         fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (nonInvertedFill == fill) {
         if (stroke.needToApply()) {
             if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-                this->stencilFillPathInstanced(
-                                    count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
-                                    writeMask, gXformType2GLType[transformsType],
-                                    transforms);
+                GL_CALL(StencilFillPathInstanced(
+                                count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
+                                writeMask, gXformType2GLType[transformsType],
+                                transforms));
             }
             this->stencilThenCoverStrokePathInstanced(
                                 count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff, writeMask,
                                 GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
                                 gXformType2GLType[transformsType], transforms);
         } else {
             this->stencilThenCoverFillPathInstanced(
                                 count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode, writeMask,
                                 GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
                                 gXformType2GLType[transformsType], transforms);
         }
     } else {
         if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-            this->stencilFillPathInstanced(
+            GL_CALL(StencilFillPathInstanced(
                                 count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
                                 writeMask, gXformType2GLType[transformsType],
-                                transforms);
+                                transforms));
         }
         if (stroke.needToApply()) {
-            this->stencilStrokePathInstanced(
+            GL_CALL(StencilStrokePathInstanced(
                                 count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff,
                                 writeMask, gXformType2GLType[transformsType],
-                                transforms);
+                                transforms));
         }
 
         GrDrawState* drawState = fGpu->drawState();
         GrDrawState::AutoViewMatrixRestore avmr;
         SkRect bounds = SkRect::MakeLTRB(0, 0,
                                          SkIntToScalar(drawState->getRenderTarget()->width()),
                                          SkIntToScalar(drawState->getRenderTarget()->height()));
         SkMatrix vmi;
         // mapRect through persp matrix may not be correct
         if (!drawState->getViewMatrix().hasPerspective() && drawState->getViewInverse(&vmi)) {
             vmi.mapRect(&bounds);
             // theoretically could set bloat = 0, instead leave it because of matrix inversion
             // precision.
             SkScalar bloat = drawState->getViewMatrix().getMaxScale() * SK_ScalarHalf;
             bounds.outset(bloat, bloat);
         } else {
             avmr.setIdentity(drawState);
         }
 
         fGpu->drawSimpleRect(bounds);
     }
 }
 
-void GrGLPathRendering::flushPathStencilSettings(SkPath::FillType fill) {
-    GrStencilSettings pathStencilSettings;
-    fGpu->getPathStencilSettingsForFillType(fill, &pathStencilSettings);
-    if (fHWPathStencilSettings != pathStencilSettings) {
-        // Just the func, ref, and mask is set here. The op and write mask are params to the call
-        // that draws the path to the SB (glStencilFillPath)
-        GrGLenum func =
-            GrToGLStencilFunc(pathStencilSettings.func(GrStencilSettings::kFront_Face));
-        this->pathStencilFunc(func, pathStencilSettings.funcRef(GrStencilSettings::kFront_Face),
-                              pathStencilSettings.funcMask(GrStencilSettings::kFront_Face));
+void GrGLPathRendering::enablePathTexGen(int unitIdx, PathTexGenComponents components,
+                                         const GrGLfloat* coefficients) {
+    SkASSERT(components >= kS_PathTexGenComponents &&
+             components <= kSTR_PathTexGenComponents);
+    SkASSERT(fGpu->glCaps().maxFixedFunctionTextureCoords() >= unitIdx);
 
-        fHWPathStencilSettings = pathStencilSettings;
+    if (GR_GL_OBJECT_LINEAR == fHWPathTexGenSettings[unitIdx].fMode &&
+        components == fHWPathTexGenSettings[unitIdx].fNumComponents &&
+        !memcmp(coefficients, fHWPathTexGenSettings[unitIdx].fCoefficients,
+                3 * components * sizeof(GrGLfloat))) {
+        return;
     }
+
+    fGpu->setTextureUnit(unitIdx);
+
+    fHWPathTexGenSettings[unitIdx].fNumComponents = components;
+    GL_CALL(PathTexGen(GR_GL_TEXTURE0 + unitIdx, GR_GL_OBJECT_LINEAR, components, coefficients));
+
+    memcpy(fHWPathTexGenSettings[unitIdx].fCoefficients, coefficients,
+           3 * components * sizeof(GrGLfloat));
+}
+
+void GrGLPathRendering::enablePathTexGen(int unitIdx, PathTexGenComponents components,
+                                         const SkMatrix& matrix) {
+    GrGLfloat coefficients[3 * 3];
+    SkASSERT(components >= kS_PathTexGenComponents &&
+             components <= kSTR_PathTexGenComponents);
+
+    coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
+    coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
+    coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);
+
+    if (components >= kST_PathTexGenComponents) {
+        coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
+        coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]);
+        coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]);
+    }
+
+    if (components >= kSTR_PathTexGenComponents) {
+        coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]);
+        coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]);
+        coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]);
+    }
+
+    this->enablePathTexGen(unitIdx, components, coefficients);
+}
+
+void GrGLPathRendering::flushPathTexGenSettings(int numUsedTexCoordSets) {
+    SkASSERT(fGpu->glCaps().maxFixedFunctionTextureCoords() >= numUsedTexCoordSets);
+
+    // Only write the inactive path tex gens, since active path tex gens were
+    // written when they were enabled.
+
+    SkDEBUGCODE(
+        for (int i = 0; i < numUsedTexCoordSets; i++) {
+            SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents);
+        }
+    );
+
+    for (int i = numUsedTexCoordSets; i < fHWActivePathTexGenSets; i++) {
+        SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents);
+
+        fGpu->setTextureUnit(i);
+        GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
+        fHWPathTexGenSettings[i].fNumComponents = 0;
+    }
+
+    fHWActivePathTexGenSets = numUsedTexCoordSets;
+}
+
+void GrGLPathRendering::setProgramPathFragmentInputTransform(GrGLuint program, GrGLint location,
+                                                             GrGLenum genMode, GrGLint components,
+                                                             const SkMatrix& matrix) {
+    SkASSERT(caps().fragmentInputGenSupport);
+    GrGLfloat coefficients[3 * 3];
+    SkASSERT(components >= 1 && components <= 3);
+
+    coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
+    coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
+    coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);
+
+    if (components >= 2) {
+        coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
+        coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]);
+        coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]);
+    }
+
+    if (components >= 3) {
+        coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]);
+        coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]);
+        coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]);
+    }
+
+    GL_CALL(ProgramPathFragmentInputGen(program, location, genMode, components, coefficients));
 }
 
 void GrGLPathRendering::setProjectionMatrix(const SkMatrix& matrix,
                                   const SkISize& renderTargetSize,
                                   GrSurfaceOrigin renderTargetOrigin) {
 
     SkASSERT(fGpu->glCaps().pathRenderingSupport());
 
     if (renderTargetOrigin == fHWProjectionMatrixState.fRenderTargetOrigin &&
         renderTargetSize == fHWProjectionMatrixState.fRenderTargetSize &&
         matrix.cheapEqualTo(fHWProjectionMatrixState.fViewMatrix)) {
         return;
     }
 
     fHWProjectionMatrixState.fViewMatrix = matrix;
     fHWProjectionMatrixState.fRenderTargetSize = renderTargetSize;
     fHWProjectionMatrixState.fRenderTargetOrigin = renderTargetOrigin;
 
     GrGLfloat glMatrix[4 * 4];
     fHWProjectionMatrixState.getRTAdjustedGLMatrix<4>(glMatrix);
     GL_CALL(MatrixLoadf(GR_GL_PROJECTION, glMatrix));
 }
 
-
-
-// NV_path_rendering
 GrGLuint GrGLPathRendering::genPaths(GrGLsizei range) {
     if (range > 1) {
         GrGLuint name;
         GL_CALL_RET(name, GenPaths(range));
         return name;
     }
 
     if (NULL == fPathNameAllocator.get()) {
         static const int range = 65536;
         GrGLuint firstName;
         GL_CALL_RET(firstName, GenPaths(range));
         fPathNameAllocator.reset(SkNEW_ARGS(GrGLNameAllocator, (firstName, firstName + range)));
     }
 
     // When allocating names one at a time, pull from a client-side pool of
     // available names in order to save a round trip to the GL server.
     GrGLuint name = fPathNameAllocator->allocateName();
 
     if (0 == name) {
         // Our reserved path names are all in use. Fall back on GenPaths.
         GL_CALL_RET(name, GenPaths(1));
     }
 
     return name;
 }
 
-GrGLvoid GrGLPathRendering::deletePaths(GrGLuint path, GrGLsizei range) {
+void GrGLPathRendering::deletePaths(GrGLuint path, GrGLsizei range) {
     if (range > 1) {
         // It is not supported to delete names in ranges that were allocated
         // individually using GrGLPathNameAllocator.
         SkASSERT(NULL == fPathNameAllocator.get() ||
                  path + range <= fPathNameAllocator->firstName() ||
                  path >= fPathNameAllocator->endName());
         GL_CALL(DeletePaths(path, range));
         return;
     }
 
     if (NULL == fPathNameAllocator.get() ||
         path < fPathNameAllocator->firstName() ||
         path >= fPathNameAllocator->endName()) {
         // If we aren't inside fPathNameAllocator's range then this name was
         // generated by the GenPaths fallback (or else was never allocated).
         GL_CALL(DeletePaths(path, 1));
         return;
     }
 
     // Make the path empty to save memory, but don't free the name in the driver.
     GL_CALL(PathCommands(path, 0, NULL, 0, GR_GL_FLOAT, NULL));
     fPathNameAllocator->free(path);
 }
 
-GrGLvoid GrGLPathRendering::pathCommands(GrGLuint path, GrGLsizei numCommands,
-                                         const GrGLubyte *commands, GrGLsizei numCoords,
-                                         GrGLenum coordType, const GrGLvoid *coords) {
-    GL_CALL(PathCommands(path, numCommands, commands, numCoords, coordType, coords));
+void GrGLPathRendering::flushPathStencilSettings(SkPath::FillType fill) {
+    GrStencilSettings pathStencilSettings;
+    fGpu->getPathStencilSettingsForFillType(fill, &pathStencilSettings);
+    if (fHWPathStencilSettings != pathStencilSettings) {
+        // Just the func, ref, and mask is set here. The op and write mask are params to the call
+        // that draws the path to the SB (glStencilFillPath)
+        GrGLenum func =
+            GrToGLStencilFunc(pathStencilSettings.func(GrStencilSettings::kFront_Face));
+        GL_CALL(PathStencilFunc(func, pathStencilSettings.funcRef(GrStencilSettings::kFront_Face),
+                                pathStencilSettings.funcMask(GrStencilSettings::kFront_Face)));
+
+        fHWPathStencilSettings = pathStencilSettings;
+    }
 }
 
-GrGLvoid GrGLPathRendering::pathCoords(GrGLuint path, GrGLsizei numCoords,
-                                       GrGLenum coordType, const GrGLvoid *coords) {
-    GL_CALL(PathCoords(path, numCoords, coordType, coords));
-}
-
-GrGLvoid GrGLPathRendering::pathParameteri(GrGLuint path, GrGLenum pname, GrGLint value) {
-    GL_CALL(PathParameteri(path, pname, value));
-}
-
-GrGLvoid GrGLPathRendering::pathParameterf(GrGLuint path, GrGLenum pname, GrGLfloat value) {
-    GL_CALL(PathParameterf(path, pname, value));
-}
-
-GrGLboolean GrGLPathRendering::isPath(GrGLuint path) {
-    GrGLboolean ret;
-    GL_CALL_RET(ret, IsPath(path));
-    return ret;
-}
-
-GrGLvoid GrGLPathRendering::pathStencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask) {
-    GL_CALL(PathStencilFunc(func, ref, mask));
-}
-
-GrGLvoid GrGLPathRendering::stencilFillPath(GrGLuint path, GrGLenum fillMode, GrGLuint mask) {
-    // Decide how to manipulate the stencil buffer based on the fill rule.
-    SkASSERT(!fHWPathStencilSettings.isTwoSided());
-
-    GL_CALL(StencilFillPath(path, fillMode, mask));
-}
-
-GrGLvoid GrGLPathRendering::stencilStrokePath(GrGLuint path, GrGLint reference, GrGLuint mask) {
-    GL_CALL(StencilStrokePath(path, reference, mask));
-}
-
-GrGLvoid GrGLPathRendering::stencilFillPathInstanced(
-             GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-             GrGLuint pathBase, GrGLenum fillMode, GrGLuint mask,
-             GrGLenum transformType, const GrGLfloat *transformValues) {
-    GL_CALL(StencilFillPathInstanced(numPaths, pathNameType, paths, pathBase,
-                                     fillMode, mask, transformType, transformValues));
-}
-
-GrGLvoid GrGLPathRendering::stencilStrokePathInstanced(
-             GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-             GrGLuint pathBase, GrGLint reference, GrGLuint mask,
-             GrGLenum transformType, const GrGLfloat *transformValues) {
-    GL_CALL(StencilStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
-                                       reference, mask, transformType, transformValues));
-}
-
-GrGLvoid GrGLPathRendering::pathTexGen(GrGLenum texCoordSet, GrGLenum genMode,
-                                       GrGLint components, const GrGLfloat *coeffs) {
-    GL_CALL(PathTexGen(texCoordSet, genMode, components, coeffs));
-}
-
-GrGLvoid GrGLPathRendering::coverFillPath(GrGLuint path, GrGLenum coverMode) {
-    GL_CALL(CoverFillPath(path, coverMode));
-}
-
-GrGLvoid GrGLPathRendering::coverStrokePath(GrGLuint name, GrGLenum coverMode) {
-    GL_CALL(CoverStrokePath(name, coverMode));
-}
-
-GrGLvoid GrGLPathRendering::coverFillPathInstanced(
-             GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase,
-             GrGLenum coverMode, GrGLenum transformType, const GrGLfloat *transformValues) {
-    GL_CALL(CoverFillPathInstanced(numPaths, pathNameType, paths, pathBase,
-                                   coverMode, transformType, transformValues));
-}
-
-GrGLvoid GrGLPathRendering::coverStrokePathInstanced(
-             GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase,
-             GrGLenum coverMode, GrGLenum transformType, const GrGLfloat* transformValues) {
-    GL_CALL(CoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
-                                     coverMode, transformType, transformValues));
-}
-
-GrGLvoid GrGLPathRendering::stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode,
+inline void GrGLPathRendering::stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode,
                                                      GrGLuint mask, GrGLenum coverMode) {
+    if (caps().thenFunctionsSupport) {
+        GL_CALL(StencilThenCoverFillPath(path, fillMode, mask, coverMode));
+        return;
+    }
     GL_CALL(StencilFillPath(path, fillMode, mask));
     GL_CALL(CoverFillPath(path, coverMode));
 }
 
-GrGLvoid GrGLPathRendering::stencilThenCoverStrokePath(GrGLuint path, GrGLint reference,
+inline void GrGLPathRendering::stencilThenCoverStrokePath(GrGLuint path, GrGLint reference,
                                                        GrGLuint mask, GrGLenum coverMode) {
+    if (caps().thenFunctionsSupport) {
+        GL_CALL(StencilThenCoverStrokePath(path, reference, mask, coverMode));
+        return;
+    }
     GL_CALL(StencilStrokePath(path, reference, mask));
     GL_CALL(CoverStrokePath(path, coverMode));
 }
 
-GrGLvoid GrGLPathRendering::stencilThenCoverFillPathInstanced(
+inline void GrGLPathRendering::stencilThenCoverFillPathInstanced(
              GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
              GrGLuint pathBase, GrGLenum fillMode, GrGLuint mask, GrGLenum coverMode,
              GrGLenum transformType, const GrGLfloat *transformValues) {
+    if (caps().thenFunctionsSupport) {
+        GL_CALL(StencilThenCoverFillPathInstanced(numPaths, pathNameType, paths, pathBase, fillMode,
+                                                  mask, coverMode, transformType, transformValues));
+        return;
+    }
     GL_CALL(StencilFillPathInstanced(numPaths, pathNameType, paths, pathBase,
                                      fillMode, mask, transformType, transformValues));
     GL_CALL(CoverFillPathInstanced(numPaths, pathNameType, paths, pathBase,
                                    coverMode, transformType, transformValues));
 }
 
-GrGLvoid GrGLPathRendering::stencilThenCoverStrokePathInstanced(
-             GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-             GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode,
-             GrGLenum transformType, const GrGLfloat *transformValues) {
+inline void GrGLPathRendering::stencilThenCoverStrokePathInstanced(
+        GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
+        GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode,
+        GrGLenum transformType, const GrGLfloat *transformValues) {
+    if (caps().thenFunctionsSupport) {
+        GL_CALL(StencilThenCoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
+                                                    reference, mask, coverMode, transformType,
+                                                    transformValues));
+        return;
+    }
+
     GL_CALL(StencilStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                        reference, mask, transformType, transformValues));
     GL_CALL(CoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                      coverMode, transformType, transformValues));
 }
-
-GrGLvoid GrGLPathRendering::programPathFragmentInputGen(
-             GrGLuint program, GrGLint location, GrGLenum genMode,
-             GrGLint components, const GrGLfloat *coeffs) {
-    SkFAIL("ProgramPathFragmentInputGen not supported in this GL context.");
-}
-
-
-// NV_path_rendering v1.2
-GrGLvoid GrGLPathRenderingV12::stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode,
-                                                        GrGLuint mask, GrGLenum coverMode) {
-    GL_CALL(StencilThenCoverFillPath(path, fillMode, mask, coverMode));
-}
-
-GrGLvoid GrGLPathRenderingV12::stencilThenCoverStrokePath(GrGLuint path, GrGLint reference,
-                                                          GrGLuint mask, GrGLenum coverMode) {
-    GL_CALL(StencilThenCoverStrokePath(path, reference, mask, coverMode));
-}
-
-GrGLvoid GrGLPathRenderingV12::stencilThenCoverFillPathInstanced(
-             GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-             GrGLuint pathBase, GrGLenum fillMode, GrGLuint mask, GrGLenum coverMode,
-             GrGLenum transformType, const GrGLfloat *transformValues) {
-    GL_CALL(StencilThenCoverFillPathInstanced(numPaths, pathNameType, paths, pathBase, fillMode,
-                                               mask, coverMode, transformType, transformValues));
-}
-
-GrGLvoid GrGLPathRenderingV12::stencilThenCoverStrokePathInstanced(
-             GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-             GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode,
-             GrGLenum transformType, const GrGLfloat *transformValues) {
-    GL_CALL(StencilThenCoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase, reference,
-                                                mask, coverMode, transformType, transformValues));
-}
-
-
-// NV_path_rendering v1.3
-GrGLvoid GrGLPathRenderingV13::programPathFragmentInputGen(
-             GrGLuint program, GrGLint location, GrGLenum genMode,
-             GrGLint components, const GrGLfloat *coeffs) {
-    GL_CALL(ProgramPathFragmentInputGen(program, location, genMode, components, coeffs));
-}