Revert of Add functions to support NV_path_rendering in OpenGL ES (https://codereview.chromium.org/345723002/)

Reason for revert:
Will have to unfortunately revert this CL in order to revert https://codereview.chromium.org/319043005/

Original issue's description:
> Add functions to support NV_path_rendering in OpenGL ES
>
> Add OpenGL ES extension functions needed to support NV_path_rendering in OpenGL
> ES.
>
> The added glProgramPathFragmentInputGenNV call is defined in NV_path_rendering
> revision 30, similar to following:
>
>     Append to the end of the "Shader Inputs" subsection of Section 3.12.2
>     "Shader Execution":
>
>     The command
>
>         void ProgramPathFragmentInputGenNV(uint program,
>                                            int location,
>                                            enum genMode,
>                                            int components,
>                                            const float *coeffs);
>
>     controls how a user-defined (non-built-in) fragment input of a
>     GLSL program object is computed for fragment shading operations that
>     occur as a result of CoverFillPathNV or CoverStrokePathNV.
>
>     /program/ names a GLSL program object.  If /program/ has not been
>     successfully linked, the error INVALID_OPERATION is generated.
>
>     The given fragment input generation state is loaded into the fragment
>     input variable location identified by /location/.  This location
>     is a value returned either by GetProgramResourceLocation with a
>     /programInterface/ of FRAGMENT_INPUT_NV and a given fragment shader
>     input variable name or by GetProgramResourceiv with FRAGMENT_INPUT_NV
>     for the /programInterface/ and LOCATION for the property for a given
>     fragment input resource index.
>
>     ....
>
> glProgramPathFragmentInputGenNV will be used instead of glPathTexGen,
> because the latter depends on fixed function pipeline that is not
> exposed in ES.
>
> Also add glGetProgramResourceLocation from OpenGL 4.3 or
> ARB_program_interface_query.
>
> Also add FRAGMENT_INPUT define to be used with glGetProgramResourceLocation.
>
> The added functions are not used yet, but they're needed when implementing
> NV_path_rendering support for OpenGL ES. They can also be used on OpenGL.
>
> Remove uncalled NV_path_rendering functions, so they do not cause confusion
> or take space in the interface definition. The ones that are later used
> can be re-added when needed.
>
> Remove definitions NV_path_rendering that are for NV_path_rendering function
> parameters that are not used. The ones that are later used
> can be re-added when needed.
>
> Committed: https://skia.googlesource.com/skia/+/4a995dfff2ecf91e8bf999d77e3218cec596232c

R=bsalomon@google.com, kkinnunen@nvidia.com
TBR=bsalomon@google.com, kkinnunen@nvidia.com
NOTREECHECKS=true
NOTRY=true

Author: rmistry@google.com

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

5 files changed, 205 insertions, 87 deletions

diff --git a/src/gpu/gl/GrGLAssembleGLESInterface.h b/src/gpu/gl/GrGLAssembleGLESInterface.h
index 2a3f4f6734..ddbc980929 100644
--- a/src/gpu/gl/GrGLAssembleGLESInterface.h
+++ b/src/gpu/gl/GrGLAssembleGLESInterface.h
@@ -233,38 +233,6 @@ const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) {
     GET_PROC(InvalidateTexImage);
     GET_PROC(InvalidateTexSubImage);
 
-    if (extensions.has("GL_EXT_direct_state_access")) {
-        GET_PROC_SUFFIX(MatrixLoadf, EXT);
-        GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
-    }
-
-#if USE_LINKED && GL_ES_VERSION_3_1
-    GET_LINKED(GetProgramResourceLocation);
-#else
-    if (version >= GR_GL_VER(3,1)) {            
-        GET_PROC(GetProgramResourceLocation);
-    }
-#endif
-
-    if (extensions.has("GL_NV_path_rendering")) {
-        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);
-        GET_PROC_SUFFIX(DeletePaths, NV);
-        GET_PROC_SUFFIX(PathStencilFunc, NV);
-        GET_PROC_SUFFIX(StencilFillPath, NV);
-        GET_PROC_SUFFIX(StencilStrokePath, NV);
-        GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
-        GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
-        GET_PROC_SUFFIX(CoverFillPath, NV);
-        GET_PROC_SUFFIX(CoverStrokePath, NV);
-        GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
-        GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
-        GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
-    }
-
     interface->fStandard = kGLES_GrGLStandard;
     interface->fExtensions.swap(&extensions);
 
diff --git a/src/gpu/gl/GrGLAssembleInterface.cpp b/src/gpu/gl/GrGLAssembleInterface.cpp
index 4c02a6eb58..98dabffe13 100644
--- a/src/gpu/gl/GrGLAssembleInterface.cpp
+++ b/src/gpu/gl/GrGLAssembleInterface.cpp
@@ -224,21 +224,53 @@ const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
     if (extensions.has("GL_NV_path_rendering")) {
         GET_PROC_SUFFIX(PathCommands, NV);
         GET_PROC_SUFFIX(PathCoords, NV);
+        GET_PROC_SUFFIX(PathSubCommands, NV);
+        GET_PROC_SUFFIX(PathSubCoords, NV);
+        GET_PROC_SUFFIX(PathString, NV);
+        GET_PROC_SUFFIX(PathGlyphs, NV);
+        GET_PROC_SUFFIX(PathGlyphRange, NV);
+        GET_PROC_SUFFIX(WeightPaths, NV);
+        GET_PROC_SUFFIX(CopyPath, NV);
+        GET_PROC_SUFFIX(InterpolatePaths, NV);
+        GET_PROC_SUFFIX(TransformPath, NV);
+        GET_PROC_SUFFIX(PathParameteriv, NV);
         GET_PROC_SUFFIX(PathParameteri, NV);
+        GET_PROC_SUFFIX(PathParameterfv, NV);
         GET_PROC_SUFFIX(PathParameterf, NV);
+        GET_PROC_SUFFIX(PathDashArray, NV);
         GET_PROC_SUFFIX(GenPaths, NV);
         GET_PROC_SUFFIX(DeletePaths, NV);
+        GET_PROC_SUFFIX(IsPath, NV);
         GET_PROC_SUFFIX(PathStencilFunc, NV);
+        GET_PROC_SUFFIX(PathStencilDepthOffset, NV);
         GET_PROC_SUFFIX(StencilFillPath, NV);
         GET_PROC_SUFFIX(StencilStrokePath, NV);
         GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
         GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
+        GET_PROC_SUFFIX(PathCoverDepthFunc, NV);
+        GET_PROC_SUFFIX(PathColorGen, NV);
         GET_PROC_SUFFIX(PathTexGen, NV);
+        GET_PROC_SUFFIX(PathFogGen, NV);
         GET_PROC_SUFFIX(CoverFillPath, NV);
         GET_PROC_SUFFIX(CoverStrokePath, NV);
         GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
         GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
-        GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
+        GET_PROC_SUFFIX(GetPathParameteriv, NV);
+        GET_PROC_SUFFIX(GetPathParameterfv, NV);
+        GET_PROC_SUFFIX(GetPathCommands, NV);
+        GET_PROC_SUFFIX(GetPathCoords, NV);
+        GET_PROC_SUFFIX(GetPathDashArray, NV);
+        GET_PROC_SUFFIX(GetPathMetrics, NV);
+        GET_PROC_SUFFIX(GetPathMetricRange, NV);
+        GET_PROC_SUFFIX(GetPathSpacing, NV);
+        GET_PROC_SUFFIX(GetPathColorGeniv, NV);
+        GET_PROC_SUFFIX(GetPathColorGenfv, NV);
+        GET_PROC_SUFFIX(GetPathTexGeniv, NV);
+        GET_PROC_SUFFIX(GetPathTexGenfv, NV);
+        GET_PROC_SUFFIX(IsPointInFillPath, NV);
+        GET_PROC_SUFFIX(IsPointInStrokePath, NV);
+        GET_PROC_SUFFIX(GetPathLength, NV);
+        GET_PROC_SUFFIX(PointAlongPath, NV);
     }
 
     if (extensions.has("GL_EXT_debug_marker")) {
@@ -256,10 +288,6 @@ const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
         GET_PROC(InvalidateTexSubImage);
     }
 
-    if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_program_interface_query")) {
-        GET_PROC(GetProgramResourceLocation);
-    }
-
     interface->fStandard = kGL_GrGLStandard;
     interface->fExtensions.swap(&extensions);
 
diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp
index 94a295cf7e..fdf6cacc08 100644
--- a/src/gpu/gl/GrGLCaps.cpp
+++ b/src/gpu/gl/GrGLCaps.cpp
@@ -312,13 +312,7 @@ bool GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
     fMaxRenderTargetSize = SkTMin(fMaxTextureSize, fMaxRenderTargetSize);
 
     fPathRenderingSupport = ctxInfo.hasExtension("GL_NV_path_rendering") &&
-        ctxInfo.hasExtension("GL_EXT_direct_state_access") &&
-        (kGL_GrGLStandard == standard &&      
-         (ctxInfo.version() >= GR_GL_VER(4,3) ||
-          ctxInfo.hasExtension("GL_ARB_program_interface_query")));
-    // Note: path rendering is not yet implemented for GLES.
-    // Once it is, this will contain also:
-    // || (kGLES_GrGLStandard == standard && ctxInfo.version() >= GR_GL_VER(3,1))
+        ctxInfo.hasExtension("GL_EXT_direct_state_access");
 
     fGpuTracingSupport = ctxInfo.hasExtension("GL_EXT_debug_marker");
 
diff --git a/src/gpu/gl/GrGLDefines.h b/src/gpu/gl/GrGLDefines.h
index 1e8d7cc278..e2ddde88c4 100644
--- a/src/gpu/gl/GrGLDefines.h
+++ b/src/gpu/gl/GrGLDefines.h
@@ -827,6 +827,19 @@
 #define GR_GL_ARC_TO                                        0xFE
 #define GR_GL_RELATIVE_ARC_TO                               0xFF
 
+// path string formats
+#define GR_GL_PATH_FORMAT_SVG                               0x9070
+#define GR_GL_PATH_FORMAT_PS                                0x9071
+
+// font targets
+#define GR_GL_STANDARD_FONT_NAME                            0x9072
+#define GR_GL_SYSTEM_FONT_NAME                              0x9073
+#define GR_GL_FILE_NAME                                     0x9074
+
+// handle missing glyphs
+#define GR_GL_SKIP_MISSING_GLYPH                            0x90A9
+#define GR_GL_USE_MISSING_GLYPH                             0x90AA
+
 // path parameters
 #define GR_GL_PATH_STROKE_WIDTH                             0x9075
 #define GR_GL_PATH_INITIAL_END_CAP                          0x9077
@@ -857,6 +870,10 @@
 #define GR_GL_COUNT_DOWN                                    0x9089
 /*      GL_PATH_FILL_MODE_NV */
 
+// path color gen
+/*      GL_PRIMARY_COLOR */
+#define GR_GL_SECONDARY_COLOR                               0x852D
+
 // gen mode
 /*      GL_NONE */
 /*      GL_EYE_LINEAR */
@@ -880,6 +897,11 @@
 #define GR_GL_TRANSPOSE_AFFINE_2D                           0x9096
 #define GR_GL_TRANSPOSE_AFFINE_3D                           0x9098
 
+// path string types
+#define GR_GL_UTF8                                          0x909A
+#define GR_GL_UTF16                                         0x909B
+
+#define GR_GL_PATH_COMPUTED_LENGTH                          0x90A0
 
 // cap/dash values
 /*      GL_FLAT */
@@ -894,9 +916,60 @@
 #define GR_GL_MITER_REVERT                                  0x90A7
 #define GR_GL_MITER_TRUNCATE                                0x90A8
 
-// NV_path_rendering extension to ARB_program_interface_query:
-// .. corresponds to the set of active input variables used by the fragment
-// shader stage of <program> (if a fragment stage exists).
-#define GR_GL_FRAGMENT_INPUT                                0x936D
+// path dash reset values
+#define GR_GL_MOVE_TO_RESETS                                0x90B5
+#define GR_GL_MOVE_TO_CONTINUES                             0x90B6
+
+// font styles
+/*      GL_NONE */
+#define GR_GL_BOLD_BIT                                      0x01
+#define GR_GL_ITALIC_BIT                                    0x02
+
+// pnames for glGet
+#define GR_GL_PATH_ERROR_POSITION                           0x90AB
+#define GR_GL_PATH_FOG_GEN_MODE                             0x90AC
+#define GR_GL_PATH_STENCIL_FUNC                             0x90B7
+#define GR_GL_PATH_STENCIL_REF                              0x90B8
+#define GR_GL_PATH_STENCIL_VALUE_MASK                       0x90B9
+#define GR_GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR              0x90BD
+#define GR_GL_PATH_STENCIL_DEPTH_OFFSET_UNITS               0x90BE
+#define GR_GL_PATH_COVER_DEPTH_FUNC                         0x90BF
+
+// per-glyph metrics bits in metric mask query
+#define GR_GL_GLYPH_WIDTH_BIT                               0x01
+#define GR_GL_GLYPH_HEIGHT_BIT                              0x02
+#define GR_GL_GLYPH_HORIZONTAL_BEARING_X_BIT                0x04
+#define GR_GL_GLYPH_HORIZONTAL_BEARING_Y_BIT                0x08
+#define GR_GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT          0x10
+#define GR_GL_GLYPH_VERTICAL_BEARING_X_BIT                  0x20
+#define GR_GL_GLYPH_VERTICAL_BEARING_Y_BIT                  0x40
+#define GR_GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT            0x80
+#define GR_GL_GLYPH_HAS_KERNING                             0x100
+
+// per-font face metrics in metric mask query
+#define GR_GL_FONT_X_MIN_BOUNDS                             0x00010000
+#define GR_GL_FONT_Y_MIN_BOUNDS                             0x00020000
+#define GR_GL_FONT_X_MAX_BOUNDS                             0x00040000
+#define GR_GL_FONT_Y_MAX_BOUNDS                             0x00080000
+#define GR_GL_FONT_UNITS_PER_EM                             0x00100000
+#define GR_GL_FONT_ASCENDER                                 0x00200000
+#define GR_GL_FONT_DESCENDER                                0x00400000
+#define GR_GL_FONT_HEIGHT                                   0x00800000
+#define GR_GL_FONT_MAX_ADVANCE_WIDTH                        0x01000000
+#define GR_GL_FONT_MAX_ADVANCE_HEIGHT                       0x02000000
+#define GR_GL_FONT_UNDERLINE_POSITION                       0x04000000
+#define GR_GL_FONT_UNDERLINE_THICKNESS                      0x08000000
+#define GR_GL_FONT_HAS_KERNING                              0x10000000
+
+// path list modes (glGetPathSpacing)
+#define GR_GL_ACCUM_ADJACENT_PAIRS                          0x90AD
+#define GR_GL_ADJACENT_PAIRS                                0x90AE
+#define GR_GL_FIRST_TO_REST                                 0x90AF
+
+//path gen modes
+#define GR_GL_PATH_GEN_MODE                                 0x90B0
+#define GR_GL_PATH_GEN_COEFF                                0x90B1
+#define GR_GL_PATH_GEN_COLOR_FORMAT                         0x90B2
+#define GR_GL_PATH_GEN_COMPONENTS                           0x90B3
 
 #endif
diff --git a/src/gpu/gl/GrGLInterface.cpp b/src/gpu/gl/GrGLInterface.cpp
index 825ad69029..b81d9ceeb8 100644
--- a/src/gpu/gl/GrGLInterface.cpp
+++ b/src/gpu/gl/GrGLInterface.cpp
@@ -39,23 +39,57 @@ const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface* interface) {
     GrGLInterface* newInterface = GrGLInterface::NewClone(interface);
 
     newInterface->fExtensions.remove("GL_NV_path_rendering");
+
     newInterface->fFunctions.fPathCommands = NULL;
     newInterface->fFunctions.fPathCoords = NULL;
+    newInterface->fFunctions.fPathSubCommands = NULL;
+    newInterface->fFunctions.fPathSubCoords = NULL;
+    newInterface->fFunctions.fPathString = NULL;
+    newInterface->fFunctions.fPathGlyphs = NULL;
+    newInterface->fFunctions.fPathGlyphRange = NULL;
+    newInterface->fFunctions.fWeightPaths = NULL;
+    newInterface->fFunctions.fCopyPath = NULL;
+    newInterface->fFunctions.fInterpolatePaths = NULL;
+    newInterface->fFunctions.fTransformPath = NULL;
+    newInterface->fFunctions.fPathParameteriv = NULL;
     newInterface->fFunctions.fPathParameteri = NULL;
+    newInterface->fFunctions.fPathParameterfv = NULL;
     newInterface->fFunctions.fPathParameterf = NULL;
+    newInterface->fFunctions.fPathDashArray = NULL;
     newInterface->fFunctions.fGenPaths = NULL;
     newInterface->fFunctions.fDeletePaths = NULL;
+    newInterface->fFunctions.fIsPath = NULL;
     newInterface->fFunctions.fPathStencilFunc = NULL;
+    newInterface->fFunctions.fPathStencilDepthOffset = NULL;
     newInterface->fFunctions.fStencilFillPath = NULL;
     newInterface->fFunctions.fStencilStrokePath = NULL;
     newInterface->fFunctions.fStencilFillPathInstanced = NULL;
     newInterface->fFunctions.fStencilStrokePathInstanced = NULL;
+    newInterface->fFunctions.fPathCoverDepthFunc = NULL;
+    newInterface->fFunctions.fPathColorGen = NULL;
     newInterface->fFunctions.fPathTexGen = NULL;
+    newInterface->fFunctions.fPathFogGen = NULL;
     newInterface->fFunctions.fCoverFillPath = NULL;
     newInterface->fFunctions.fCoverStrokePath = NULL;
     newInterface->fFunctions.fCoverFillPathInstanced = NULL;
     newInterface->fFunctions.fCoverStrokePathInstanced = NULL;
-    newInterface->fFunctions.fProgramPathFragmentInputGen = NULL;
+    newInterface->fFunctions.fGetPathParameteriv = NULL;
+    newInterface->fFunctions.fGetPathParameterfv = NULL;
+    newInterface->fFunctions.fGetPathCommands = NULL;
+    newInterface->fFunctions.fGetPathCoords = NULL;
+    newInterface->fFunctions.fGetPathDashArray = NULL;
+    newInterface->fFunctions.fGetPathMetrics = NULL;
+    newInterface->fFunctions.fGetPathMetricRange = NULL;
+    newInterface->fFunctions.fGetPathSpacing = NULL;
+    newInterface->fFunctions.fGetPathColorGeniv = NULL;
+    newInterface->fFunctions.fGetPathColorGenfv = NULL;
+    newInterface->fFunctions.fGetPathTexGeniv = NULL;
+    newInterface->fFunctions.fGetPathTexGenfv = NULL;
+    newInterface->fFunctions.fIsPointInFillPath = NULL;
+    newInterface->fFunctions.fIsPointInStrokePath = NULL;
+    newInterface->fFunctions.fGetPathLength = NULL;
+    newInterface->fFunctions.fPointAlongPath = NULL;
+
     return newInterface;
 }
 
@@ -258,6 +292,65 @@ bool GrGLInterface::validate() const {
                 RETURN_FALSE_INTERFACE
             }
         }
+        if (fExtensions.has("GL_EXT_direct_state_access")) {
+            if (NULL == fFunctions.fMatrixLoadf ||
+                NULL == fFunctions.fMatrixLoadIdentity) {
+                RETURN_FALSE_INTERFACE
+            }
+        }
+        if (fExtensions.has("GL_NV_path_rendering")) {
+            if (NULL == fFunctions.fPathCommands ||
+                NULL == fFunctions.fPathCoords ||
+                NULL == fFunctions.fPathSubCommands ||
+                NULL == fFunctions.fPathSubCoords ||
+                NULL == fFunctions.fPathString ||
+                NULL == fFunctions.fPathGlyphs ||
+                NULL == fFunctions.fPathGlyphRange ||
+                NULL == fFunctions.fWeightPaths ||
+                NULL == fFunctions.fCopyPath ||
+                NULL == fFunctions.fInterpolatePaths ||
+                NULL == fFunctions.fTransformPath ||
+                NULL == fFunctions.fPathParameteriv ||
+                NULL == fFunctions.fPathParameteri ||
+                NULL == fFunctions.fPathParameterfv ||
+                NULL == fFunctions.fPathParameterf ||
+                NULL == fFunctions.fPathDashArray ||
+                NULL == fFunctions.fGenPaths ||
+                NULL == fFunctions.fDeletePaths ||
+                NULL == fFunctions.fIsPath ||
+                NULL == fFunctions.fPathStencilFunc ||
+                NULL == fFunctions.fPathStencilDepthOffset ||
+                NULL == fFunctions.fStencilFillPath ||
+                NULL == fFunctions.fStencilStrokePath ||
+                NULL == fFunctions.fStencilFillPathInstanced ||
+                NULL == fFunctions.fStencilStrokePathInstanced ||
+                NULL == fFunctions.fPathCoverDepthFunc ||
+                NULL == fFunctions.fPathColorGen ||
+                NULL == fFunctions.fPathTexGen ||
+                NULL == fFunctions.fPathFogGen ||
+                NULL == fFunctions.fCoverFillPath ||
+                NULL == fFunctions.fCoverStrokePath ||
+                NULL == fFunctions.fCoverFillPathInstanced ||
+                NULL == fFunctions.fCoverStrokePathInstanced ||
+                NULL == fFunctions.fGetPathParameteriv ||
+                NULL == fFunctions.fGetPathParameterfv ||
+                NULL == fFunctions.fGetPathCommands ||
+                NULL == fFunctions.fGetPathCoords ||
+                NULL == fFunctions.fGetPathDashArray ||
+                NULL == fFunctions.fGetPathMetrics ||
+                NULL == fFunctions.fGetPathMetricRange ||
+                NULL == fFunctions.fGetPathSpacing ||
+                NULL == fFunctions.fGetPathColorGeniv ||
+                NULL == fFunctions.fGetPathColorGenfv ||
+                NULL == fFunctions.fGetPathTexGeniv ||
+                NULL == fFunctions.fGetPathTexGenfv ||
+                NULL == fFunctions.fIsPointInFillPath ||
+                NULL == fFunctions.fIsPointInStrokePath ||
+                NULL == fFunctions.fGetPathLength ||
+                NULL == fFunctions.fPointAlongPath) {
+                RETURN_FALSE_INTERFACE
+            }
+        }
     }
 
     // optional function on desktop before 1.3
@@ -433,43 +526,5 @@ bool GrGLInterface::validate() const {
             RETURN_FALSE_INTERFACE;
         }
     }
-    if (fExtensions.has("GL_EXT_direct_state_access")) {
-        if (NULL == fFunctions.fMatrixLoadf ||
-            NULL == fFunctions.fMatrixLoadIdentity) {
-            RETURN_FALSE_INTERFACE
-        }
-    }
-    if ((kGL_GrGLStandard == fStandard && glVer >= GR_GL_VER(4,3)) ||
-        fExtensions.has("GL_ARB_program_interface_query")) {
-        if (NULL == fFunctions.fGetProgramResourceLocation) {
-            RETURN_FALSE_INTERFACE
-        }
-    }
-    if (fExtensions.has("GL_NV_path_rendering")) {
-        if (NULL == fFunctions.fPathCommands ||
-            NULL == fFunctions.fPathCoords ||
-            NULL == fFunctions.fPathParameteri ||
-            NULL == fFunctions.fPathParameterf ||
-            NULL == fFunctions.fGenPaths ||
-            NULL == fFunctions.fDeletePaths ||
-            NULL == fFunctions.fPathStencilFunc ||
-            NULL == fFunctions.fStencilFillPath ||
-            NULL == fFunctions.fStencilStrokePath ||
-            NULL == fFunctions.fStencilFillPathInstanced ||
-            NULL == fFunctions.fStencilStrokePathInstanced ||
-            NULL == fFunctions.fCoverFillPath ||
-            NULL == fFunctions.fCoverStrokePath ||
-            NULL == fFunctions.fCoverFillPathInstanced ||
-            NULL == fFunctions.fCoverStrokePathInstanced) {
-            RETURN_FALSE_INTERFACE
-        }
-        // Currently ProgramPathFragmentInputGen is not used on
-        // OpenGL, rather PathTexGen is.
-        if ((kGL_GrGLStandard == fStandard && NULL == fFunctions.fPathTexGen) ||
-            (kGLES_GrGLStandard == fStandard && NULL == fFunctions.fProgramPathFragmentInputGen)) {
-            RETURN_FALSE_INTERFACE
-        }
-    }
-
     return true;
 }