Revert of Cleanup legacy NVPR-related definitions

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/GrGLNameAllocator.h"
 #include "gl/GrGLUtil.h"
@@ skipping 43 matching lines @@
             /* fallthrough */;
         case kIncClamp_StencilOp:
             return GR_GL_COUNT_UP;
         case kInvert_StencilOp:
             return GR_GL_INVERT;
     }
 }
 
 GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
     : GrPathRendering(gpu) {
+    const GrGLInterface* glInterface = gpu->glInterface();
+    fCaps.stencilThenCoverSupport =
+        NULL != glInterface->fFunctions.fStencilThenCoverFillPath &&
+        NULL != glInterface->fFunctions.fStencilThenCoverStrokePath &&
+        NULL != glInterface->fFunctions.fStencilThenCoverFillPathInstanced &&
+        NULL != glInterface->fFunctions.fStencilThenCoverStrokePathInstanced;
+    fCaps.fragmentInputGenSupport =
+        NULL != glInterface->fFunctions.fProgramPathFragmentInputGen;
+
+    SkASSERT(fCaps.fragmentInputGenSupport);
 }
 
 GrGLPathRendering::~GrGLPathRendering() {
 }
 
 void GrGLPathRendering::abandonGpuResources() {
     fPathNameAllocator.reset(NULL);
 }
 
 void GrGLPathRendering::resetContext() {
     fHWProjectionMatrixState.invalidate();
     // we don't use the model view matrix.
     GL_CALL(MatrixLoadIdentity(GR_GL_PATH_MODELVIEW));
 
+    SkASSERT(fCaps.fragmentInputGenSupport);
     fHWPathStencilSettings.invalidate();
 }
 
 GrPath* GrGLPathRendering::createPath(const SkPath& inPath, const GrStrokeInfo& stroke) {
     return SkNEW_ARGS(GrGLPath, (this->gpu(), inPath, stroke));
 }
 
 GrPathRange* GrGLPathRendering::createPathRange(GrPathRange::PathGenerator* pathGenerator,
                                                 const GrStrokeInfo& stroke) {
     return SkNEW_ARGS(GrGLPathRange, (this->gpu(), pathGenerator, stroke));
@@ skipping 39 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 (glPath->shouldStroke()) {
         if (glPath->shouldFill()) {
             GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
         }
-        GL_CALL(StencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask,
-                                           GR_GL_BOUNDING_BOX));
+        this->stencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask, GR_GL_BOUNDING_BOX);
     } else {
-        GL_CALL(StencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask,
-                                         GR_GL_BOUNDING_BOX));
+        this->stencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask, GR_GL_BOUNDING_BOX);
     }
 }
 
 void GrGLPathRendering::onDrawPaths(const DrawPathArgs& args, const GrPathRange* pathRange,
                                     const void* indices, PathIndexType indexType,
                                     const float transformValues[], PathTransformType transformType,
                                     int count) {
     if (!this->gpu()->flushGLState(args)) {
         return;
     }
     this->flushPathStencilSettings(*args.fStencil);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
 
     const GrGLPathRange* glPathRange = static_cast<const GrGLPathRange*>(pathRange);
 
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(
             fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask =
         fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (glPathRange->shouldStroke()) {
         if (glPathRange->shouldFill()) {
             GL_CALL(StencilFillPathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             fillMode, writeMask, gXformType2GLType[transformType],
                             transformValues));
         }
-        GL_CALL(StencilThenCoverStrokePathInstanced(
+        this->stencilThenCoverStrokePathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             0xffff, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                            gXformType2GLType[transformType], transformValues));
+                            gXformType2GLType[transformType], transformValues);
     } else {
-        GL_CALL(StencilThenCoverFillPathInstanced(
+        this->stencilThenCoverFillPathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             fillMode, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                            gXformType2GLType[transformType], transformValues));
+                            gXformType2GLType[transformType], transformValues);
     }
 }
 
 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]);
@@ skipping 87 matching lines @@
         // that draws the path to the SB (glStencilFillPath)
         GrGLenum func =
             GrToGLStencilFunc(stencilSettings.func(GrStencilSettings::kFront_Face));
         GL_CALL(PathStencilFunc(func, stencilSettings.funcRef(GrStencilSettings::kFront_Face),
                                 stencilSettings.funcMask(GrStencilSettings::kFront_Face)));
 
         fHWPathStencilSettings = stencilSettings;
     }
 }
 
+inline void GrGLPathRendering::stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode,
+                                                     GrGLuint mask, GrGLenum coverMode) {
+    if (caps().stencilThenCoverSupport) {
+        GL_CALL(StencilThenCoverFillPath(path, fillMode, mask, coverMode));
+        return;
+    }
+    GL_CALL(StencilFillPath(path, fillMode, mask));
+    GL_CALL(CoverFillPath(path, coverMode));
+}
+
+inline void GrGLPathRendering::stencilThenCoverStrokePath(GrGLuint path, GrGLint reference,
+                                                       GrGLuint mask, GrGLenum coverMode) {
+    if (caps().stencilThenCoverSupport) {
+        GL_CALL(StencilThenCoverStrokePath(path, reference, mask, coverMode));
+        return;
+    }
+    GL_CALL(StencilStrokePath(path, reference, mask));
+    GL_CALL(CoverStrokePath(path, coverMode));
+}
+
+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().stencilThenCoverSupport) {
+        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));
+}
+
+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().stencilThenCoverSupport) {
+        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));
+}
+
 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }