Cleanup legacy NVPR-related definitions

Fixed-function NVPR codepaths were removed a while ago. Only NVPR API
version 1.3 (PathFragmentInputGen) was left working. Remove
backwards-compatibility code that was left behind.

Remove some NVPR API function typedefs that were left from initial
commits.

Remove PathCoords function pointer from GrGLInterface, it has
never been called and causes problems in the future, since it will
not be implemented in the Chromium pseudo extension.

Review URL: https://codereview.chromium.org/1177243004

diff --git a/include/gpu/gl/GrGLFunctions.h b/include/gpu/gl/GrGLFunctions.h
index a3b9cca..f5240c5 100644 (file)
--- a/include/gpu/gl/GrGLFunctions.h
+++ b/include/gpu/gl/GrGLFunctions.h
@@ -236,15 +236,6 @@ typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLViewportProc)(GrGLint x, GrGLint y, G
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLMatrixLoadfProc)(GrGLenum matrixMode, const GrGLfloat* m);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLMatrixLoadIdentityProc)(GrGLenum);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathCommandsProc)(GrGLuint path, GrGLsizei numCommands, const GrGLubyte *commands, GrGLsizei numCoords, GrGLenum coordType, const GrGLvoid *coords);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathCoordsProc)(GrGLuint path, GrGLsizei numCoords, GrGLenum coordType, const GrGLvoid *coords);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathSubCoordsProc)(GrGLuint path, GrGLsizei coordStart, GrGLsizei numCoords, GrGLenum coordType, const GrGLvoid *coords);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathStringProc)(GrGLuint path, GrGLenum format, GrGLsizei length, const GrGLvoid *pathString);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathGlyphsProc)(GrGLuint firstPathName, GrGLenum fontTarget, const GrGLvoid *fontName, GrGLbitfield fontStyle, GrGLsizei numGlyphs, GrGLenum type, const GrGLvoid *charcodes, GrGLenum handleMissingGlyphs, GrGLuint pathParameterTemplate, GrGLfloat emScale);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathGlyphRangeProc)(GrGLuint firstPathName, GrGLenum fontTarget, const GrGLvoid *fontName, GrGLbitfield fontStyle, GrGLuint firstGlyph, GrGLsizei numGlyphs, GrGLenum handleMissingGlyphs, GrGLuint pathParameterTemplate, GrGLfloat emScale);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLWeightPathsProc)(GrGLuint resultPath, GrGLsizei numPaths, const GrGLuint paths[], const GrGLfloat weights[]);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLCopyPathProc)(GrGLuint resultPath, GrGLuint srcPath);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLInterpolatePathsProc)(GrGLuint resultPath, GrGLuint pathA, GrGLuint pathB, GrGLfloat weight);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLTransformPathProc)(GrGLuint resultPath, GrGLuint srcPath, GrGLenum transformType, const GrGLfloat *transformValues);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathParameteriProc)(GrGLuint path, GrGLenum pname, GrGLint value);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathParameterfProc)(GrGLuint path, GrGLenum pname, GrGLfloat value);
 typedef GrGLuint (GR_GL_FUNCTION_TYPE* GrGLGenPathsProc)(GrGLsizei range);
@@ -255,7 +246,6 @@ typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLStencilFillPathProc)(GrGLuint path, G
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLStencilStrokePathProc)(GrGLuint path, GrGLint reference, GrGLuint mask);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLStencilFillPathInstancedProc)(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLenum fillMode, GrGLuint mask, GrGLenum transformType, const GrGLfloat *transformValues);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLStencilStrokePathInstancedProc)(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum transformType, const GrGLfloat *transformValues);
-typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLPathTexGenProc)(GrGLenum texCoordSet, GrGLenum genMode, GrGLint components, const GrGLfloat *coeffs);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLCoverFillPathProc)(GrGLuint path, GrGLenum coverMode);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLCoverStrokePathProc)(GrGLuint name, GrGLenum coverMode);
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLCoverFillPathInstancedProc)(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLenum coverMode, GrGLenum transformType, const GrGLfloat *transformValues);

diff --git a/include/gpu/gl/GrGLInterface.h b/include/gpu/gl/GrGLInterface.h
index 8c72526..2398c37 100644 (file)
--- a/include/gpu/gl/GrGLInterface.h
+++ b/include/gpu/gl/GrGLInterface.h
@@ -329,7 +329,6 @@ public:
         GLPtr<GrGLMatrixLoadIdentityProc> fMatrixLoadIdentity;
         GLPtr<GrGLGetProgramResourceLocationProc> fGetProgramResourceLocation;
         GLPtr<GrGLPathCommandsProc> fPathCommands;
-        GLPtr<GrGLPathCoordsProc> fPathCoords;
         GLPtr<GrGLPathParameteriProc> fPathParameteri;
         GLPtr<GrGLPathParameterfProc> fPathParameterf;
         GLPtr<GrGLGenPathsProc> fGenPaths;
@@ -340,7 +339,6 @@ public:
         GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;
         GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;
         GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;
-        GLPtr<GrGLPathTexGenProc> fPathTexGen;
         GLPtr<GrGLCoverFillPathProc> fCoverFillPath;
         GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;
         GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;

diff --git a/src/gpu/gl/GrGLAssembleInterface.cpp b/src/gpu/gl/GrGLAssembleInterface.cpp
index 1fe53eb..3f66c03 100644 (file)
--- a/src/gpu/gl/GrGLAssembleInterface.cpp
+++ b/src/gpu/gl/GrGLAssembleInterface.cpp
@@ -273,7 +273,6 @@ const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
         GET_PROC_SUFFIX(MatrixLoadf, EXT);
         GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
         GET_PROC_SUFFIX(PathCommands, NV);
-        GET_PROC_SUFFIX(PathCoords, NV);
         GET_PROC_SUFFIX(PathParameteri, NV);
         GET_PROC_SUFFIX(PathParameterf, NV);
         GET_PROC_SUFFIX(GenPaths, NV);
@@ -284,17 +283,14 @@ const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
         GET_PROC_SUFFIX(StencilStrokePath, NV);
         GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
         GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
-        GET_PROC_SUFFIX(PathTexGen, NV);
         GET_PROC_SUFFIX(CoverFillPath, NV);
         GET_PROC_SUFFIX(CoverStrokePath, NV);
         GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
         GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
-        // NV_path_rendering v1.2 (These methods may not be present)
         GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
         GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
-        // NV_path_rendering v1.3 (These methods may not be present)
         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
     }
 
@@ -682,7 +678,6 @@ const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) {
         GET_PROC_SUFFIX(MatrixLoadf, EXT);
         GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
         GET_PROC_SUFFIX(PathCommands, NV);
-        GET_PROC_SUFFIX(PathCoords, NV);
         GET_PROC_SUFFIX(PathParameteri, NV);
         GET_PROC_SUFFIX(PathParameterf, NV);
         GET_PROC_SUFFIX(GenPaths, NV);

diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 98d0ffc..3d6c9fe 100644 (file)
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -54,8 +54,7 @@ public:
 
     void discard(GrRenderTarget*) override;
 
-    // Used by GrGLProgram and GrGLPathTexGenProgramEffects to configure OpenGL
-    // state.
+    // Used by GrGLProgram to configure OpenGL state.
     void bindTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture);
 
     // GrGpu overrides

diff --git a/src/gpu/gl/GrGLInterface.cpp b/src/gpu/gl/GrGLInterface.cpp
index 3d44f6d..3c80880 100644 (file)
--- a/src/gpu/gl/GrGLInterface.cpp
+++ b/src/gpu/gl/GrGLInterface.cpp
@@ -40,7 +40,6 @@ const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface* interface) {
 
     newInterface->fExtensions.remove("GL_NV_path_rendering");
     newInterface->fFunctions.fPathCommands = NULL;
-    newInterface->fFunctions.fPathCoords = NULL;
     newInterface->fFunctions.fPathParameteri = NULL;
     newInterface->fFunctions.fPathParameterf = NULL;
     newInterface->fFunctions.fGenPaths = NULL;
@@ -51,7 +50,6 @@ const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface* interface) {
     newInterface->fFunctions.fStencilStrokePath = NULL;
     newInterface->fFunctions.fStencilFillPathInstanced = NULL;
     newInterface->fFunctions.fStencilStrokePathInstanced = NULL;
-    newInterface->fFunctions.fPathTexGen = NULL;
     newInterface->fFunctions.fCoverFillPath = NULL;
     newInterface->fFunctions.fCoverStrokePath = NULL;
     newInterface->fFunctions.fCoverFillPathInstanced = NULL;
@@ -489,7 +487,6 @@ bool GrGLInterface::validate() const {
         if (NULL == fFunctions.fMatrixLoadf ||
             NULL == fFunctions.fMatrixLoadIdentity ||
             NULL == fFunctions.fPathCommands ||
-            NULL == fFunctions.fPathCoords ||
             NULL == fFunctions.fPathParameteri ||
             NULL == fFunctions.fPathParameterf ||
             NULL == fFunctions.fGenPaths ||
@@ -503,24 +500,14 @@ bool GrGLInterface::validate() const {
             NULL == fFunctions.fCoverFillPath ||
             NULL == fFunctions.fCoverStrokePath ||
             NULL == fFunctions.fCoverFillPathInstanced ||
-            NULL == fFunctions.fCoverStrokePathInstanced) {
+            NULL == fFunctions.fCoverStrokePathInstanced ||
+            NULL == fFunctions.fStencilThenCoverFillPath ||
+            NULL == fFunctions.fStencilThenCoverStrokePath ||
+            NULL == fFunctions.fStencilThenCoverFillPathInstanced ||
+            NULL == fFunctions.fStencilThenCoverStrokePathInstanced ||
+            NULL == fFunctions.fProgramPathFragmentInputGen) {
             RETURN_FALSE_INTERFACE
         }
-        if (kGL_GrGLStandard == fStandard) {
-            // Some methods only exist on desktop
-            if (NULL == fFunctions.fPathTexGen) {
-                RETURN_FALSE_INTERFACE
-            }
-        } else {
-            // All additions through v1.3 exist on GLES
-            if (NULL == fFunctions.fStencilThenCoverFillPath ||
-                NULL == fFunctions.fStencilThenCoverStrokePath ||
-                NULL == fFunctions.fStencilThenCoverFillPathInstanced ||
-                NULL == fFunctions.fStencilThenCoverStrokePathInstanced ||
-                NULL == fFunctions.fProgramPathFragmentInputGen) {
-                RETURN_FALSE_INTERFACE
-            }
-        }
     }
 
     if (fExtensions.has("GL_EXT_raster_multisample")) {

diff --git a/src/gpu/gl/GrGLPathRendering.cpp b/src/gpu/gl/GrGLPathRendering.cpp
index eb9f5a8..ffdbbda 100644 (file)
--- a/src/gpu/gl/GrGLPathRendering.cpp
+++ b/src/gpu/gl/GrGLPathRendering.cpp
@@ -61,16 +61,6 @@ static GrGLenum gr_stencil_op_to_gl_path_rendering_fill_mode(GrStencilOp op) {
 
 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() {
@@ -85,7 +75,6 @@ void GrGLPathRendering::resetContext() {
     // we don't use the model view matrix.
     GL_CALL(MatrixLoadIdentity(GR_GL_PATH_MODELVIEW));
 
-    SkASSERT(fCaps.fragmentInputGenSupport);
     fHWPathStencilSettings.invalidate();
 }
 
@@ -145,9 +134,11 @@ void GrGLPathRendering::onDrawPath(const DrawPathArgs& args, const GrPath* path)
         if (glPath->shouldFill()) {
             GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
         }
-        this->stencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask, GR_GL_BOUNDING_BOX);
+        GL_CALL(StencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask,
+                                           GR_GL_BOUNDING_BOX));
     } else {
-        this->stencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask, GR_GL_BOUNDING_BOX);
+        GL_CALL(StencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask,
+                                         GR_GL_BOUNDING_BOX));
     }
 }
 
@@ -177,22 +168,21 @@ void GrGLPathRendering::onDrawPaths(const DrawPathArgs& args, const GrPathRange*
                             fillMode, writeMask, gXformType2GLType[transformType],
                             transformValues));
         }
-        this->stencilThenCoverStrokePathInstanced(
+        GL_CALL(StencilThenCoverStrokePathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             0xffff, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                            gXformType2GLType[transformType], transformValues);
+                            gXformType2GLType[transformType], transformValues));
     } else {
-        this->stencilThenCoverFillPathInstanced(
+        GL_CALL(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);
 
@@ -300,58 +290,6 @@ void GrGLPathRendering::flushPathStencilSettings(const GrStencilSettings& stenci
     }
 }
 
-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);
 }

diff --git a/src/gpu/gl/GrGLPathRendering.h b/src/gpu/gl/GrGLPathRendering.h
index 20fd496..86cf1b1 100644 (file)
--- a/src/gpu/gl/GrGLPathRendering.h
+++ b/src/gpu/gl/GrGLPathRendering.h
@@ -65,35 +65,8 @@ protected:
     void onDrawPaths(const DrawPathArgs&, const GrPathRange*, const void* indices, PathIndexType,
                      const float transformValues[], PathTransformType, int count) override;
 private:
-    /**
-     * Mark certain functionality as not supported if the driver version is too
-     * old and a backup implementation is not practical.
-     */
-    struct Caps {
-        bool stencilThenCoverSupport : 1;
-        bool fragmentInputGenSupport : 1;
-    };
-    const Caps& caps() const { return fCaps; }
-
     void flushPathStencilSettings(const GrStencilSettings&);
 
-    // NV_path_rendering v1.2
-    void stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode,
-                                  GrGLuint mask, GrGLenum coverMode);
-
-    void stencilThenCoverStrokePath(GrGLuint path, GrGLint reference,
-                                    GrGLuint mask, GrGLenum coverMode);
-
-    void stencilThenCoverFillPathInstanced(
-        GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-                         GrGLuint pathBase, GrGLenum fillMode, GrGLuint mask, GrGLenum coverMode,
-                         GrGLenum transformType, const GrGLfloat *transformValues);
-
-    void stencilThenCoverStrokePathInstanced(
-                         GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths,
-                         GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode,
-                         GrGLenum transformType, const GrGLfloat *transformValues);
-
     struct MatrixState {
         SkMatrix        fViewMatrix;
         SkISize         fRenderTargetSize;
@@ -128,14 +101,8 @@ private:
     GrGLGpu* gpu();
 
     SkAutoTDelete<GrGLNameAllocator> fPathNameAllocator;
-    Caps fCaps;
     MatrixState fHWProjectionMatrixState;
     GrStencilSettings fHWPathStencilSettings;
-    struct PathTexGenData {
-        GrGLenum  fMode;
-        GrGLint   fNumComponents;
-        GrGLfloat fCoefficients[3 * 3];
-    };
 };
 
 #endif