command_buffer: Implement path rendering functions for CHROMIUM_path_rendering

ui/gl/gl_bindings_autogen_gl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file is auto-generated from
 // ui/gl/generate_bindings.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 76 matching lines @@
   fn.glCompressedTexSubImage2DFn =
       reinterpret_cast<glCompressedTexSubImage2DProc>(
           GetGLProcAddress("glCompressedTexSubImage2D"));
   fn.glCompressedTexSubImage3DFn = 0;
   fn.glCopyBufferSubDataFn = 0;
   fn.glCopyTexImage2DFn = reinterpret_cast<glCopyTexImage2DProc>(
       GetGLProcAddress("glCopyTexImage2D"));
   fn.glCopyTexSubImage2DFn = reinterpret_cast<glCopyTexSubImage2DProc>(
       GetGLProcAddress("glCopyTexSubImage2D"));
   fn.glCopyTexSubImage3DFn = 0;
+  fn.glCoverFillPathNVFn = 0;
+  fn.glCoverStrokePathNVFn = 0;
   fn.glCreateProgramFn = reinterpret_cast<glCreateProgramProc>(
       GetGLProcAddress("glCreateProgram"));
   fn.glCreateShaderFn =
       reinterpret_cast<glCreateShaderProc>(GetGLProcAddress("glCreateShader"));
   fn.glCullFaceFn =
       reinterpret_cast<glCullFaceProc>(GetGLProcAddress("glCullFace"));
   fn.glDeleteBuffersARBFn = reinterpret_cast<glDeleteBuffersARBProc>(
       GetGLProcAddress("glDeleteBuffers"));
   fn.glDeleteFencesAPPLEFn = 0;
   fn.glDeleteFencesNVFn = 0;
   fn.glDeleteFramebuffersEXTFn = 0;
+  fn.glDeletePathsNVFn = 0;
   fn.glDeleteProgramFn = reinterpret_cast<glDeleteProgramProc>(
       GetGLProcAddress("glDeleteProgram"));
   fn.glDeleteQueriesFn = 0;
   fn.glDeleteRenderbuffersEXTFn = 0;
   fn.glDeleteSamplersFn = 0;
   fn.glDeleteShaderFn =
       reinterpret_cast<glDeleteShaderProc>(GetGLProcAddress("glDeleteShader"));
   fn.glDeleteSyncFn = 0;
   fn.glDeleteTexturesFn = reinterpret_cast<glDeleteTexturesProc>(
       GetGLProcAddress("glDeleteTextures"));
@@ skipping 43 matching lines @@
   fn.glFramebufferTexture2DMultisampleIMGFn = 0;
   fn.glFramebufferTextureLayerFn = 0;
   fn.glFrontFaceFn =
       reinterpret_cast<glFrontFaceProc>(GetGLProcAddress("glFrontFace"));
   fn.glGenBuffersARBFn =
       reinterpret_cast<glGenBuffersARBProc>(GetGLProcAddress("glGenBuffers"));
   fn.glGenerateMipmapEXTFn = 0;
   fn.glGenFencesAPPLEFn = 0;
   fn.glGenFencesNVFn = 0;
   fn.glGenFramebuffersEXTFn = 0;
+  fn.glGenPathsNVFn = 0;
   fn.glGenQueriesFn = 0;
   fn.glGenRenderbuffersEXTFn = 0;
   fn.glGenSamplersFn = 0;
   fn.glGenTexturesFn =
       reinterpret_cast<glGenTexturesProc>(GetGLProcAddress("glGenTextures"));
   fn.glGenTransformFeedbacksFn = 0;
   fn.glGenVertexArraysOESFn = 0;
   fn.glGetActiveAttribFn = reinterpret_cast<glGetActiveAttribProc>(
       GetGLProcAddress("glGetActiveAttrib"));
   fn.glGetActiveUniformFn = reinterpret_cast<glGetActiveUniformProc>(
@@ skipping 77 matching lines @@
   fn.glInsertEventMarkerEXTFn = 0;
   fn.glInvalidateFramebufferFn = 0;
   fn.glInvalidateSubFramebufferFn = 0;
   fn.glIsBufferFn =
       reinterpret_cast<glIsBufferProc>(GetGLProcAddress("glIsBuffer"));
   fn.glIsEnabledFn =
       reinterpret_cast<glIsEnabledProc>(GetGLProcAddress("glIsEnabled"));
   fn.glIsFenceAPPLEFn = 0;
   fn.glIsFenceNVFn = 0;
   fn.glIsFramebufferEXTFn = 0;
+  fn.glIsPathNVFn = 0;
   fn.glIsProgramFn =
       reinterpret_cast<glIsProgramProc>(GetGLProcAddress("glIsProgram"));
   fn.glIsQueryFn = 0;
   fn.glIsRenderbufferEXTFn = 0;
   fn.glIsSamplerFn = 0;
   fn.glIsShaderFn =
       reinterpret_cast<glIsShaderProc>(GetGLProcAddress("glIsShader"));
   fn.glIsSyncFn = 0;
   fn.glIsTextureFn =
       reinterpret_cast<glIsTextureProc>(GetGLProcAddress("glIsTexture"));
   fn.glIsTransformFeedbackFn = 0;
   fn.glIsVertexArrayOESFn = 0;
   fn.glLineWidthFn =
       reinterpret_cast<glLineWidthProc>(GetGLProcAddress("glLineWidth"));
   fn.glLinkProgramFn =
       reinterpret_cast<glLinkProgramProc>(GetGLProcAddress("glLinkProgram"));
   fn.glMapBufferFn = 0;
   fn.glMapBufferRangeFn = 0;
   fn.glMatrixLoadfEXTFn = 0;
   fn.glMatrixLoadIdentityEXTFn = 0;
+  fn.glPathCommandsNVFn = 0;
+  fn.glPathParameterfNVFn = 0;
+  fn.glPathParameteriNVFn = 0;
+  fn.glPathStencilFuncNVFn = 0;
   fn.glPauseTransformFeedbackFn = 0;
   fn.glPixelStoreiFn =
       reinterpret_cast<glPixelStoreiProc>(GetGLProcAddress("glPixelStorei"));
   fn.glPointParameteriFn = 0;
   fn.glPolygonOffsetFn = reinterpret_cast<glPolygonOffsetProc>(
       GetGLProcAddress("glPolygonOffset"));
   fn.glPopGroupMarkerEXTFn = 0;
   fn.glProgramBinaryFn = 0;
   fn.glProgramParameteriFn = 0;
   fn.glPushGroupMarkerEXTFn = 0;
@@ skipping 14 matching lines @@
   fn.glSamplerParameterfvFn = 0;
   fn.glSamplerParameteriFn = 0;
   fn.glSamplerParameterivFn = 0;
   fn.glScissorFn =
       reinterpret_cast<glScissorProc>(GetGLProcAddress("glScissor"));
   fn.glSetFenceAPPLEFn = 0;
   fn.glSetFenceNVFn = 0;
   fn.glShaderBinaryFn = 0;
   fn.glShaderSourceFn =
       reinterpret_cast<glShaderSourceProc>(GetGLProcAddress("glShaderSource"));
+  fn.glStencilFillPathNVFn = 0;
   fn.glStencilFuncFn =
       reinterpret_cast<glStencilFuncProc>(GetGLProcAddress("glStencilFunc"));
   fn.glStencilFuncSeparateFn = reinterpret_cast<glStencilFuncSeparateProc>(
       GetGLProcAddress("glStencilFuncSeparate"));
   fn.glStencilMaskFn =
       reinterpret_cast<glStencilMaskProc>(GetGLProcAddress("glStencilMask"));
   fn.glStencilMaskSeparateFn = reinterpret_cast<glStencilMaskSeparateProc>(
       GetGLProcAddress("glStencilMaskSeparate"));
   fn.glStencilOpFn =
       reinterpret_cast<glStencilOpProc>(GetGLProcAddress("glStencilOp"));
   fn.glStencilOpSeparateFn = reinterpret_cast<glStencilOpSeparateProc>(
       GetGLProcAddress("glStencilOpSeparate"));
+  fn.glStencilStrokePathNVFn = 0;
+  fn.glStencilThenCoverFillPathNVFn = 0;
+  fn.glStencilThenCoverStrokePathNVFn = 0;
   fn.glTestFenceAPPLEFn = 0;
   fn.glTestFenceNVFn = 0;
   fn.glTexImage2DFn =
       reinterpret_cast<glTexImage2DProc>(GetGLProcAddress("glTexImage2D"));
   fn.glTexImage3DFn = 0;
   fn.glTexParameterfFn = reinterpret_cast<glTexParameterfProc>(
       GetGLProcAddress("glTexParameterf"));
   fn.glTexParameterfvFn = reinterpret_cast<glTexParameterfvProc>(
       GetGLProcAddress("glTexParameterfv"));
   fn.glTexParameteriFn = reinterpret_cast<glTexParameteriProc>(
@@ skipping 413 matching lines @@
     DCHECK(fn.glCopyBufferSubDataFn);
   }
 
   debug_fn.glCopyTexSubImage3DFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glCopyTexSubImage3DFn = reinterpret_cast<glCopyTexSubImage3DProc>(
         GetGLProcAddress("glCopyTexSubImage3D"));
     DCHECK(fn.glCopyTexSubImage3DFn);
   }
 
+  debug_fn.glCoverFillPathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverFillPathNVFn = reinterpret_cast<glCoverFillPathNVProc>(
+        GetGLProcAddress("glCoverFillPathNV"));
+    DCHECK(fn.glCoverFillPathNVFn);
+  }
+
+  debug_fn.glCoverStrokePathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverStrokePathNVFn = reinterpret_cast<glCoverStrokePathNVProc>(
+        GetGLProcAddress("glCoverStrokePathNV"));
+    DCHECK(fn.glCoverStrokePathNVFn);
+  }
+
   debug_fn.glDeleteFencesAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glDeleteFencesAPPLEFn = reinterpret_cast<glDeleteFencesAPPLEProc>(
         GetGLProcAddress("glDeleteFencesAPPLE"));
     DCHECK(fn.glDeleteFencesAPPLEFn);
   }
 
   debug_fn.glDeleteFencesNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glDeleteFencesNVFn = reinterpret_cast<glDeleteFencesNVProc>(
         GetGLProcAddress("glDeleteFencesNV"));
     DCHECK(fn.glDeleteFencesNVFn);
   }
 
   debug_fn.glDeleteFramebuffersEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glDeleteFramebuffersEXTFn =
         reinterpret_cast<glDeleteFramebuffersEXTProc>(
             GetGLProcAddress("glDeleteFramebuffers"));
     DCHECK(fn.glDeleteFramebuffersEXTFn);
   } else if (ext.b_GL_EXT_framebuffer_object) {
     fn.glDeleteFramebuffersEXTFn =
         reinterpret_cast<glDeleteFramebuffersEXTProc>(
             GetGLProcAddress("glDeleteFramebuffersEXT"));
     DCHECK(fn.glDeleteFramebuffersEXTFn);
   }
 
+  debug_fn.glDeletePathsNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glDeletePathsNVFn = reinterpret_cast<glDeletePathsNVProc>(
+        GetGLProcAddress("glDeletePathsNV"));
+    DCHECK(fn.glDeletePathsNVFn);
+  }
+
   debug_fn.glDeleteQueriesFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
         GetGLProcAddress("glDeleteQueries"));
     DCHECK(fn.glDeleteQueriesFn);
   } else if (ext.b_GL_ARB_occlusion_query) {
     fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
         GetGLProcAddress("glDeleteQueriesARB"));
     DCHECK(fn.glDeleteQueriesFn);
   } else if (ext.b_GL_EXT_disjoint_timer_query ||
@@ skipping 286 matching lines @@
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glGenFramebuffersEXTFn = reinterpret_cast<glGenFramebuffersEXTProc>(
         GetGLProcAddress("glGenFramebuffers"));
     DCHECK(fn.glGenFramebuffersEXTFn);
   } else if (ext.b_GL_EXT_framebuffer_object) {
     fn.glGenFramebuffersEXTFn = reinterpret_cast<glGenFramebuffersEXTProc>(
         GetGLProcAddress("glGenFramebuffersEXT"));
     DCHECK(fn.glGenFramebuffersEXTFn);
   }
 
+  debug_fn.glGenPathsNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glGenPathsNVFn =
+        reinterpret_cast<glGenPathsNVProc>(GetGLProcAddress("glGenPathsNV"));
+    DCHECK(fn.glGenPathsNVFn);
+  }
+
   debug_fn.glGenQueriesFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGenQueriesFn =
         reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueries"));
     DCHECK(fn.glGenQueriesFn);
   } else if (ext.b_GL_ARB_occlusion_query) {
     fn.glGenQueriesFn =
         reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueriesARB"));
     DCHECK(fn.glGenQueriesFn);
   } else if (ext.b_GL_EXT_disjoint_timer_query ||
@@ skipping 374 matching lines @@
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glIsFramebufferEXTFn = reinterpret_cast<glIsFramebufferEXTProc>(
         GetGLProcAddress("glIsFramebuffer"));
     DCHECK(fn.glIsFramebufferEXTFn);
   } else if (ext.b_GL_EXT_framebuffer_object) {
     fn.glIsFramebufferEXTFn = reinterpret_cast<glIsFramebufferEXTProc>(
         GetGLProcAddress("glIsFramebufferEXT"));
     DCHECK(fn.glIsFramebufferEXTFn);
   }
 
+  debug_fn.glIsPathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glIsPathNVFn =
+        reinterpret_cast<glIsPathNVProc>(GetGLProcAddress("glIsPathNV"));
+    DCHECK(fn.glIsPathNVFn);
+  }
+
   debug_fn.glIsQueryFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glIsQueryFn =
         reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQuery"));
     DCHECK(fn.glIsQueryFn);
   } else if (ext.b_GL_ARB_occlusion_query) {
     fn.glIsQueryFn =
         reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQueryARB"));
     DCHECK(fn.glIsQueryFn);
   } else if (ext.b_GL_EXT_disjoint_timer_query ||
@@ skipping 83 matching lines @@
   }
 
   debug_fn.glMatrixLoadIdentityEXTFn = 0;
   if (ext.b_GL_EXT_direct_state_access || ext.b_GL_NV_path_rendering) {
     fn.glMatrixLoadIdentityEXTFn =
         reinterpret_cast<glMatrixLoadIdentityEXTProc>(
             GetGLProcAddress("glMatrixLoadIdentityEXT"));
     DCHECK(fn.glMatrixLoadIdentityEXTFn);
   }
 
+  debug_fn.glPathCommandsNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathCommandsNVFn = reinterpret_cast<glPathCommandsNVProc>(
+        GetGLProcAddress("glPathCommandsNV"));
+    DCHECK(fn.glPathCommandsNVFn);
+  }
+
+  debug_fn.glPathParameterfNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathParameterfNVFn = reinterpret_cast<glPathParameterfNVProc>(
+        GetGLProcAddress("glPathParameterfNV"));
+    DCHECK(fn.glPathParameterfNVFn);
+  }
+
+  debug_fn.glPathParameteriNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathParameteriNVFn = reinterpret_cast<glPathParameteriNVProc>(
+        GetGLProcAddress("glPathParameteriNV"));
+    DCHECK(fn.glPathParameteriNVFn);
+  }
+
+  debug_fn.glPathStencilFuncNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathStencilFuncNVFn = reinterpret_cast<glPathStencilFuncNVProc>(
+        GetGLProcAddress("glPathStencilFuncNV"));
+    DCHECK(fn.glPathStencilFuncNVFn);
+  }
+
   debug_fn.glPauseTransformFeedbackFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u)) {
     fn.glPauseTransformFeedbackFn =
         reinterpret_cast<glPauseTransformFeedbackProc>(
             GetGLProcAddress("glPauseTransformFeedback"));
     DCHECK(fn.glPauseTransformFeedbackFn);
   }
 
   debug_fn.glPointParameteriFn = 0;
   if (!ver->is_es) {
@@ skipping 158 matching lines @@
     DCHECK(fn.glSetFenceNVFn);
   }
 
   debug_fn.glShaderBinaryFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
     fn.glShaderBinaryFn = reinterpret_cast<glShaderBinaryProc>(
         GetGLProcAddress("glShaderBinary"));
     DCHECK(fn.glShaderBinaryFn);
   }
 
+  debug_fn.glStencilFillPathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilFillPathNVFn = reinterpret_cast<glStencilFillPathNVProc>(
+        GetGLProcAddress("glStencilFillPathNV"));
+    DCHECK(fn.glStencilFillPathNVFn);
+  }
+
+  debug_fn.glStencilStrokePathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilStrokePathNVFn = reinterpret_cast<glStencilStrokePathNVProc>(
+        GetGLProcAddress("glStencilStrokePathNV"));
+    DCHECK(fn.glStencilStrokePathNVFn);
+  }
+
+  debug_fn.glStencilThenCoverFillPathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverFillPathNVFn =
+        reinterpret_cast<glStencilThenCoverFillPathNVProc>(
+            GetGLProcAddress("glStencilThenCoverFillPathNV"));
+  }
+
+  debug_fn.glStencilThenCoverStrokePathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverStrokePathNVFn =
+        reinterpret_cast<glStencilThenCoverStrokePathNVProc>(
+            GetGLProcAddress("glStencilThenCoverStrokePathNV"));
+  }
+
   debug_fn.glTestFenceAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glTestFenceAPPLEFn = reinterpret_cast<glTestFenceAPPLEProc>(
         GetGLProcAddress("glTestFenceAPPLE"));
     DCHECK(fn.glTestFenceAPPLEFn);
   }
 
   debug_fn.glTestFenceNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glTestFenceNVFn =
@@ skipping 716 matching lines @@
                                                       GLsizei height) {
   GL_SERVICE_LOG("glCopyTexSubImage3D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << xoffset << ", " << yoffset << ", " << zoffset
                  << ", " << x << ", " << y << ", " << width << ", " << height
                  << ")");
   g_driver_gl.debug_fn.glCopyTexSubImage3DFn(target, level, xoffset, yoffset,
                                              zoffset, x, y, width, height);
 }
 
+static void GL_BINDING_CALL
+Debug_glCoverFillPathNV(GLuint path, GLenum coverMode) {
+  GL_SERVICE_LOG("glCoverFillPathNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(coverMode)
+                 << ")");
+  g_driver_gl.debug_fn.glCoverFillPathNVFn(path, coverMode);
+}
+
+static void GL_BINDING_CALL
+Debug_glCoverStrokePathNV(GLuint name, GLenum coverMode) {
+  GL_SERVICE_LOG("glCoverStrokePathNV"
+                 << "(" << name << ", " << GLEnums::GetStringEnum(coverMode)
+                 << ")");
+  g_driver_gl.debug_fn.glCoverStrokePathNVFn(name, coverMode);
+}
+
 static GLuint GL_BINDING_CALL Debug_glCreateProgram(void) {
   GL_SERVICE_LOG("glCreateProgram"
                  << "("
                  << ")");
   GLuint result = g_driver_gl.debug_fn.glCreateProgramFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLuint GL_BINDING_CALL Debug_glCreateShader(GLenum type) {
@@ skipping 35 matching lines @@
 }
 
 static void GL_BINDING_CALL
 Debug_glDeleteFramebuffersEXT(GLsizei n, const GLuint* framebuffers) {
   GL_SERVICE_LOG("glDeleteFramebuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(framebuffers)
                  << ")");
   g_driver_gl.debug_fn.glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
+static void GL_BINDING_CALL Debug_glDeletePathsNV(GLuint path, GLsizei range) {
+  GL_SERVICE_LOG("glDeletePathsNV"
+                 << "(" << path << ", " << range << ")");
+  g_driver_gl.debug_fn.glDeletePathsNVFn(path, range);
+}
+
 static void GL_BINDING_CALL Debug_glDeleteProgram(GLuint program) {
   GL_SERVICE_LOG("glDeleteProgram"
                  << "(" << program << ")");
   g_driver_gl.debug_fn.glDeleteProgramFn(program);
 }
 
 static void GL_BINDING_CALL
 Debug_glDeleteQueries(GLsizei n, const GLuint* ids) {
   GL_SERVICE_LOG("glDeleteQueries"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
@@ skipping 373 matching lines @@
 }
 
 static void GL_BINDING_CALL
 Debug_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) {
   GL_SERVICE_LOG("glGenFramebuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(framebuffers)
                  << ")");
   g_driver_gl.debug_fn.glGenFramebuffersEXTFn(n, framebuffers);
 }
 
+static GLuint GL_BINDING_CALL Debug_glGenPathsNV(GLsizei range) {
+  GL_SERVICE_LOG("glGenPathsNV"
+                 << "(" << range << ")");
+  GLuint result = g_driver_gl.debug_fn.glGenPathsNVFn(range);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static void GL_BINDING_CALL Debug_glGenQueries(GLsizei n, GLuint* ids) {
   GL_SERVICE_LOG("glGenQueries"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
   g_driver_gl.debug_fn.glGenQueriesFn(n, ids);
 }
 
 static void GL_BINDING_CALL
 Debug_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers) {
   GL_SERVICE_LOG("glGenRenderbuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(renderbuffers)
@@ skipping 662 matching lines @@
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsFramebufferEXT(GLuint framebuffer) {
   GL_SERVICE_LOG("glIsFramebufferEXT"
                  << "(" << framebuffer << ")");
   GLboolean result = g_driver_gl.debug_fn.glIsFramebufferEXTFn(framebuffer);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
+static GLboolean GL_BINDING_CALL Debug_glIsPathNV(GLuint path) {
+  GL_SERVICE_LOG("glIsPathNV"
+                 << "(" << path << ")");
+  GLboolean result = g_driver_gl.debug_fn.glIsPathNVFn(path);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static GLboolean GL_BINDING_CALL Debug_glIsProgram(GLuint program) {
   GL_SERVICE_LOG("glIsProgram"
                  << "(" << program << ")");
   GLboolean result = g_driver_gl.debug_fn.glIsProgramFn(program);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsQuery(GLuint query) {
   GL_SERVICE_LOG("glIsQuery"
@@ skipping 101 matching lines @@
                  << static_cast<const void*>(m) << ")");
   g_driver_gl.debug_fn.glMatrixLoadfEXTFn(matrixMode, m);
 }
 
 static void GL_BINDING_CALL Debug_glMatrixLoadIdentityEXT(GLenum matrixMode) {
   GL_SERVICE_LOG("glMatrixLoadIdentityEXT"
                  << "(" << GLEnums::GetStringEnum(matrixMode) << ")");
   g_driver_gl.debug_fn.glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
+static void GL_BINDING_CALL Debug_glPathCommandsNV(GLuint path,
+                                                   GLsizei numCommands,
+                                                   const GLubyte* commands,
+                                                   GLsizei numCoords,
+                                                   GLenum coordType,
+                                                   const GLvoid* coords) {
+  GL_SERVICE_LOG("glPathCommandsNV"
+                 << "(" << path << ", " << numCommands << ", "
+                 << static_cast<const void*>(commands) << ", " << numCoords
+                 << ", " << GLEnums::GetStringEnum(coordType) << ", "
+                 << static_cast<const void*>(coords) << ")");
+  g_driver_gl.debug_fn.glPathCommandsNVFn(path, numCommands, commands,
+                                          numCoords, coordType, coords);
+}
+
+static void GL_BINDING_CALL
+Debug_glPathParameterfNV(GLuint path, GLenum pname, GLfloat value) {
+  GL_SERVICE_LOG("glPathParameterfNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << value << ")");
+  g_driver_gl.debug_fn.glPathParameterfNVFn(path, pname, value);
+}
+
+static void GL_BINDING_CALL
+Debug_glPathParameteriNV(GLuint path, GLenum pname, GLint value) {
+  GL_SERVICE_LOG("glPathParameteriNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << value << ")");
+  g_driver_gl.debug_fn.glPathParameteriNVFn(path, pname, value);
+}
+
+static void GL_BINDING_CALL
+Debug_glPathStencilFuncNV(GLenum func, GLint ref, GLuint mask) {
+  GL_SERVICE_LOG("glPathStencilFuncNV"
+                 << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
+                 << mask << ")");
+  g_driver_gl.debug_fn.glPathStencilFuncNVFn(func, ref, mask);
+}
+
 static void GL_BINDING_CALL Debug_glPauseTransformFeedback(void) {
   GL_SERVICE_LOG("glPauseTransformFeedback"
                  << "("
                  << ")");
   g_driver_gl.debug_fn.glPauseTransformFeedbackFn();
 }
 
 static void GL_BINDING_CALL Debug_glPixelStorei(GLenum pname, GLint param) {
   GL_SERVICE_LOG("glPixelStorei"
                  << "(" << GLEnums::GetStringEnum(pname) << ", " << param
@@ skipping 254 matching lines @@
           GL_SERVICE_LOG("  " << ii << ": ---\n" << str[ii] << "\n---");
         }
       } else {
         GL_SERVICE_LOG("  " << ii << ": NULL");
       }
     }
   });
 }
 
 static void GL_BINDING_CALL
+Debug_glStencilFillPathNV(GLuint path, GLenum fillMode, GLuint mask) {
+  GL_SERVICE_LOG("glStencilFillPathNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
+                 << ", " << mask << ")");
+  g_driver_gl.debug_fn.glStencilFillPathNVFn(path, fillMode, mask);
+}
+
+static void GL_BINDING_CALL
 Debug_glStencilFunc(GLenum func, GLint ref, GLuint mask) {
   GL_SERVICE_LOG("glStencilFunc"
                  << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
                  << mask << ")");
   g_driver_gl.debug_fn.glStencilFuncFn(func, ref, mask);
 }
 
 static void GL_BINDING_CALL
 Debug_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
   GL_SERVICE_LOG("glStencilFuncSeparate"
@@ skipping 30 matching lines @@
                                                       GLenum zfail,
                                                       GLenum zpass) {
   GL_SERVICE_LOG("glStencilOpSeparate"
                  << "(" << GLEnums::GetStringEnum(face) << ", "
                  << GLEnums::GetStringEnum(fail) << ", "
                  << GLEnums::GetStringEnum(zfail) << ", "
                  << GLEnums::GetStringEnum(zpass) << ")");
   g_driver_gl.debug_fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
+static void GL_BINDING_CALL
+Debug_glStencilStrokePathNV(GLuint path, GLint reference, GLuint mask) {
+  GL_SERVICE_LOG("glStencilStrokePathNV"
+                 << "(" << path << ", " << reference << ", " << mask << ")");
+  g_driver_gl.debug_fn.glStencilStrokePathNVFn(path, reference, mask);
+}
+
+static void GL_BINDING_CALL
+Debug_glStencilThenCoverFillPathNV(GLuint path,
+                                   GLenum fillMode,
+                                   GLuint mask,
+                                   GLenum coverMode) {
+  GL_SERVICE_LOG("glStencilThenCoverFillPathNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
+                 << ", " << mask << ", " << GLEnums::GetStringEnum(coverMode)
+                 << ")");
+  g_driver_gl.debug_fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask,
+                                                      coverMode);
+}
+
+static void GL_BINDING_CALL
+Debug_glStencilThenCoverStrokePathNV(GLuint path,
+                                     GLint reference,
+                                     GLuint mask,
+                                     GLenum coverMode) {
+  GL_SERVICE_LOG("glStencilThenCoverStrokePathNV"
+                 << "(" << path << ", " << reference << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(coverMode) << ")");
+  g_driver_gl.debug_fn.glStencilThenCoverStrokePathNVFn(path, reference, mask,
+                                                        coverMode);
+}
+
 static GLboolean GL_BINDING_CALL Debug_glTestFenceAPPLE(GLuint fence) {
   GL_SERVICE_LOG("glTestFenceAPPLE"
                  << "(" << fence << ")");
   GLboolean result = g_driver_gl.debug_fn.glTestFenceAPPLEFn(fence);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glTestFenceNV(GLuint fence) {
   GL_SERVICE_LOG("glTestFenceNV"
@@ skipping 813 matching lines @@
     fn.glCopyTexImage2DFn = Debug_glCopyTexImage2D;
   }
   if (!debug_fn.glCopyTexSubImage2DFn) {
     debug_fn.glCopyTexSubImage2DFn = fn.glCopyTexSubImage2DFn;
     fn.glCopyTexSubImage2DFn = Debug_glCopyTexSubImage2D;
   }
   if (!debug_fn.glCopyTexSubImage3DFn) {
     debug_fn.glCopyTexSubImage3DFn = fn.glCopyTexSubImage3DFn;
     fn.glCopyTexSubImage3DFn = Debug_glCopyTexSubImage3D;
   }
+  if (!debug_fn.glCoverFillPathNVFn) {
+    debug_fn.glCoverFillPathNVFn = fn.glCoverFillPathNVFn;
+    fn.glCoverFillPathNVFn = Debug_glCoverFillPathNV;
+  }
+  if (!debug_fn.glCoverStrokePathNVFn) {
+    debug_fn.glCoverStrokePathNVFn = fn.glCoverStrokePathNVFn;
+    fn.glCoverStrokePathNVFn = Debug_glCoverStrokePathNV;
+  }
   if (!debug_fn.glCreateProgramFn) {
     debug_fn.glCreateProgramFn = fn.glCreateProgramFn;
     fn.glCreateProgramFn = Debug_glCreateProgram;
   }
   if (!debug_fn.glCreateShaderFn) {
     debug_fn.glCreateShaderFn = fn.glCreateShaderFn;
     fn.glCreateShaderFn = Debug_glCreateShader;
   }
   if (!debug_fn.glCullFaceFn) {
     debug_fn.glCullFaceFn = fn.glCullFaceFn;
     fn.glCullFaceFn = Debug_glCullFace;
   }
   if (!debug_fn.glDeleteBuffersARBFn) {
     debug_fn.glDeleteBuffersARBFn = fn.glDeleteBuffersARBFn;
     fn.glDeleteBuffersARBFn = Debug_glDeleteBuffersARB;
   }
   if (!debug_fn.glDeleteFencesAPPLEFn) {
     debug_fn.glDeleteFencesAPPLEFn = fn.glDeleteFencesAPPLEFn;
     fn.glDeleteFencesAPPLEFn = Debug_glDeleteFencesAPPLE;
   }
   if (!debug_fn.glDeleteFencesNVFn) {
     debug_fn.glDeleteFencesNVFn = fn.glDeleteFencesNVFn;
     fn.glDeleteFencesNVFn = Debug_glDeleteFencesNV;
   }
   if (!debug_fn.glDeleteFramebuffersEXTFn) {
     debug_fn.glDeleteFramebuffersEXTFn = fn.glDeleteFramebuffersEXTFn;
     fn.glDeleteFramebuffersEXTFn = Debug_glDeleteFramebuffersEXT;
   }
+  if (!debug_fn.glDeletePathsNVFn) {
+    debug_fn.glDeletePathsNVFn = fn.glDeletePathsNVFn;
+    fn.glDeletePathsNVFn = Debug_glDeletePathsNV;
+  }
   if (!debug_fn.glDeleteProgramFn) {
     debug_fn.glDeleteProgramFn = fn.glDeleteProgramFn;
     fn.glDeleteProgramFn = Debug_glDeleteProgram;
   }
   if (!debug_fn.glDeleteQueriesFn) {
     debug_fn.glDeleteQueriesFn = fn.glDeleteQueriesFn;
     fn.glDeleteQueriesFn = Debug_glDeleteQueries;
   }
   if (!debug_fn.glDeleteRenderbuffersEXTFn) {
     debug_fn.glDeleteRenderbuffersEXTFn = fn.glDeleteRenderbuffersEXTFn;
@@ skipping 174 matching lines @@
     fn.glGenFencesAPPLEFn = Debug_glGenFencesAPPLE;
   }
   if (!debug_fn.glGenFencesNVFn) {
     debug_fn.glGenFencesNVFn = fn.glGenFencesNVFn;
     fn.glGenFencesNVFn = Debug_glGenFencesNV;
   }
   if (!debug_fn.glGenFramebuffersEXTFn) {
     debug_fn.glGenFramebuffersEXTFn = fn.glGenFramebuffersEXTFn;
     fn.glGenFramebuffersEXTFn = Debug_glGenFramebuffersEXT;
   }
+  if (!debug_fn.glGenPathsNVFn) {
+    debug_fn.glGenPathsNVFn = fn.glGenPathsNVFn;
+    fn.glGenPathsNVFn = Debug_glGenPathsNV;
+  }
   if (!debug_fn.glGenQueriesFn) {
     debug_fn.glGenQueriesFn = fn.glGenQueriesFn;
     fn.glGenQueriesFn = Debug_glGenQueries;
   }
   if (!debug_fn.glGenRenderbuffersEXTFn) {
     debug_fn.glGenRenderbuffersEXTFn = fn.glGenRenderbuffersEXTFn;
     fn.glGenRenderbuffersEXTFn = Debug_glGenRenderbuffersEXT;
   }
   if (!debug_fn.glGenSamplersFn) {
     debug_fn.glGenSamplersFn = fn.glGenSamplersFn;
@@ skipping 263 matching lines @@
     fn.glIsFenceAPPLEFn = Debug_glIsFenceAPPLE;
   }
   if (!debug_fn.glIsFenceNVFn) {
     debug_fn.glIsFenceNVFn = fn.glIsFenceNVFn;
     fn.glIsFenceNVFn = Debug_glIsFenceNV;
   }
   if (!debug_fn.glIsFramebufferEXTFn) {
     debug_fn.glIsFramebufferEXTFn = fn.glIsFramebufferEXTFn;
     fn.glIsFramebufferEXTFn = Debug_glIsFramebufferEXT;
   }
+  if (!debug_fn.glIsPathNVFn) {
+    debug_fn.glIsPathNVFn = fn.glIsPathNVFn;
+    fn.glIsPathNVFn = Debug_glIsPathNV;
+  }
   if (!debug_fn.glIsProgramFn) {
     debug_fn.glIsProgramFn = fn.glIsProgramFn;
     fn.glIsProgramFn = Debug_glIsProgram;
   }
   if (!debug_fn.glIsQueryFn) {
     debug_fn.glIsQueryFn = fn.glIsQueryFn;
     fn.glIsQueryFn = Debug_glIsQuery;
   }
   if (!debug_fn.glIsRenderbufferEXTFn) {
     debug_fn.glIsRenderbufferEXTFn = fn.glIsRenderbufferEXTFn;
@@ skipping 40 matching lines @@
     fn.glMapBufferRangeFn = Debug_glMapBufferRange;
   }
   if (!debug_fn.glMatrixLoadfEXTFn) {
     debug_fn.glMatrixLoadfEXTFn = fn.glMatrixLoadfEXTFn;
     fn.glMatrixLoadfEXTFn = Debug_glMatrixLoadfEXT;
   }
   if (!debug_fn.glMatrixLoadIdentityEXTFn) {
     debug_fn.glMatrixLoadIdentityEXTFn = fn.glMatrixLoadIdentityEXTFn;
     fn.glMatrixLoadIdentityEXTFn = Debug_glMatrixLoadIdentityEXT;
   }
+  if (!debug_fn.glPathCommandsNVFn) {
+    debug_fn.glPathCommandsNVFn = fn.glPathCommandsNVFn;
+    fn.glPathCommandsNVFn = Debug_glPathCommandsNV;
+  }
+  if (!debug_fn.glPathParameterfNVFn) {
+    debug_fn.glPathParameterfNVFn = fn.glPathParameterfNVFn;
+    fn.glPathParameterfNVFn = Debug_glPathParameterfNV;
+  }
+  if (!debug_fn.glPathParameteriNVFn) {
+    debug_fn.glPathParameteriNVFn = fn.glPathParameteriNVFn;
+    fn.glPathParameteriNVFn = Debug_glPathParameteriNV;
+  }
+  if (!debug_fn.glPathStencilFuncNVFn) {
+    debug_fn.glPathStencilFuncNVFn = fn.glPathStencilFuncNVFn;
+    fn.glPathStencilFuncNVFn = Debug_glPathStencilFuncNV;
+  }
   if (!debug_fn.glPauseTransformFeedbackFn) {
     debug_fn.glPauseTransformFeedbackFn = fn.glPauseTransformFeedbackFn;
     fn.glPauseTransformFeedbackFn = Debug_glPauseTransformFeedback;
   }
   if (!debug_fn.glPixelStoreiFn) {
     debug_fn.glPixelStoreiFn = fn.glPixelStoreiFn;
     fn.glPixelStoreiFn = Debug_glPixelStorei;
   }
   if (!debug_fn.glPointParameteriFn) {
     debug_fn.glPointParameteriFn = fn.glPointParameteriFn;
@@ skipping 100 matching lines @@
     fn.glSetFenceNVFn = Debug_glSetFenceNV;
   }
   if (!debug_fn.glShaderBinaryFn) {
     debug_fn.glShaderBinaryFn = fn.glShaderBinaryFn;
     fn.glShaderBinaryFn = Debug_glShaderBinary;
   }
   if (!debug_fn.glShaderSourceFn) {
     debug_fn.glShaderSourceFn = fn.glShaderSourceFn;
     fn.glShaderSourceFn = Debug_glShaderSource;
   }
+  if (!debug_fn.glStencilFillPathNVFn) {
+    debug_fn.glStencilFillPathNVFn = fn.glStencilFillPathNVFn;
+    fn.glStencilFillPathNVFn = Debug_glStencilFillPathNV;
+  }
   if (!debug_fn.glStencilFuncFn) {
     debug_fn.glStencilFuncFn = fn.glStencilFuncFn;
     fn.glStencilFuncFn = Debug_glStencilFunc;
   }
   if (!debug_fn.glStencilFuncSeparateFn) {
     debug_fn.glStencilFuncSeparateFn = fn.glStencilFuncSeparateFn;
     fn.glStencilFuncSeparateFn = Debug_glStencilFuncSeparate;
   }
   if (!debug_fn.glStencilMaskFn) {
     debug_fn.glStencilMaskFn = fn.glStencilMaskFn;
     fn.glStencilMaskFn = Debug_glStencilMask;
   }
   if (!debug_fn.glStencilMaskSeparateFn) {
     debug_fn.glStencilMaskSeparateFn = fn.glStencilMaskSeparateFn;
     fn.glStencilMaskSeparateFn = Debug_glStencilMaskSeparate;
   }
   if (!debug_fn.glStencilOpFn) {
     debug_fn.glStencilOpFn = fn.glStencilOpFn;
     fn.glStencilOpFn = Debug_glStencilOp;
   }
   if (!debug_fn.glStencilOpSeparateFn) {
     debug_fn.glStencilOpSeparateFn = fn.glStencilOpSeparateFn;
     fn.glStencilOpSeparateFn = Debug_glStencilOpSeparate;
   }
+  if (!debug_fn.glStencilStrokePathNVFn) {
+    debug_fn.glStencilStrokePathNVFn = fn.glStencilStrokePathNVFn;
+    fn.glStencilStrokePathNVFn = Debug_glStencilStrokePathNV;
+  }
+  if (!debug_fn.glStencilThenCoverFillPathNVFn) {
+    debug_fn.glStencilThenCoverFillPathNVFn = fn.glStencilThenCoverFillPathNVFn;
+    fn.glStencilThenCoverFillPathNVFn = Debug_glStencilThenCoverFillPathNV;
+  }
+  if (!debug_fn.glStencilThenCoverStrokePathNVFn) {
+    debug_fn.glStencilThenCoverStrokePathNVFn =
+        fn.glStencilThenCoverStrokePathNVFn;
+    fn.glStencilThenCoverStrokePathNVFn = Debug_glStencilThenCoverStrokePathNV;
+  }
   if (!debug_fn.glTestFenceAPPLEFn) {
     debug_fn.glTestFenceAPPLEFn = fn.glTestFenceAPPLEFn;
     fn.glTestFenceAPPLEFn = Debug_glTestFenceAPPLE;
   }
   if (!debug_fn.glTestFenceNVFn) {
     debug_fn.glTestFenceNVFn = fn.glTestFenceNVFn;
     fn.glTestFenceNVFn = Debug_glTestFenceNV;
   }
   if (!debug_fn.glTexImage2DFn) {
     debug_fn.glTexImage2DFn = fn.glTexImage2DFn;
@@ skipping 586 matching lines @@
                                       GLint yoffset,
                                       GLint zoffset,
                                       GLint x,
                                       GLint y,
                                       GLsizei width,
                                       GLsizei height) {
   driver_->fn.glCopyTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, x,
                                     y, width, height);
 }
 
+void GLApiBase::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+  driver_->fn.glCoverFillPathNVFn(path, coverMode);
+}
+
+void GLApiBase::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+  driver_->fn.glCoverStrokePathNVFn(name, coverMode);
+}
+
 GLuint GLApiBase::glCreateProgramFn(void) {
   return driver_->fn.glCreateProgramFn();
 }
 
 GLuint GLApiBase::glCreateShaderFn(GLenum type) {
   return driver_->fn.glCreateShaderFn(type);
 }
 
 void GLApiBase::glCullFaceFn(GLenum mode) {
   driver_->fn.glCullFaceFn(mode);
 }
 
 void GLApiBase::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
   driver_->fn.glDeleteBuffersARBFn(n, buffers);
 }
 
 void GLApiBase::glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) {
   driver_->fn.glDeleteFencesAPPLEFn(n, fences);
 }
 
 void GLApiBase::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
   driver_->fn.glDeleteFencesNVFn(n, fences);
 }
 
 void GLApiBase::glDeleteFramebuffersEXTFn(GLsizei n,
                                           const GLuint* framebuffers) {
   driver_->fn.glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
+void GLApiBase::glDeletePathsNVFn(GLuint path, GLsizei range) {
+  driver_->fn.glDeletePathsNVFn(path, range);
+}
+
 void GLApiBase::glDeleteProgramFn(GLuint program) {
   driver_->fn.glDeleteProgramFn(program);
 }
 
 void GLApiBase::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
   driver_->fn.glDeleteQueriesFn(n, ids);
 }
 
 void GLApiBase::glDeleteRenderbuffersEXTFn(GLsizei n,
                                            const GLuint* renderbuffers) {
@@ skipping 217 matching lines @@
 }
 
 void GLApiBase::glGenFencesNVFn(GLsizei n, GLuint* fences) {
   driver_->fn.glGenFencesNVFn(n, fences);
 }
 
 void GLApiBase::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
   driver_->fn.glGenFramebuffersEXTFn(n, framebuffers);
 }
 
+GLuint GLApiBase::glGenPathsNVFn(GLsizei range) {
+  return driver_->fn.glGenPathsNVFn(range);
+}
+
 void GLApiBase::glGenQueriesFn(GLsizei n, GLuint* ids) {
   driver_->fn.glGenQueriesFn(n, ids);
 }
 
 void GLApiBase::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
   driver_->fn.glGenRenderbuffersEXTFn(n, renderbuffers);
 }
 
 void GLApiBase::glGenSamplersFn(GLsizei n, GLuint* samplers) {
   driver_->fn.glGenSamplersFn(n, samplers);
@@ skipping 382 matching lines @@
 }
 
 GLboolean GLApiBase::glIsFenceNVFn(GLuint fence) {
   return driver_->fn.glIsFenceNVFn(fence);
 }
 
 GLboolean GLApiBase::glIsFramebufferEXTFn(GLuint framebuffer) {
   return driver_->fn.glIsFramebufferEXTFn(framebuffer);
 }
 
+GLboolean GLApiBase::glIsPathNVFn(GLuint path) {
+  return driver_->fn.glIsPathNVFn(path);
+}
+
 GLboolean GLApiBase::glIsProgramFn(GLuint program) {
   return driver_->fn.glIsProgramFn(program);
 }
 
 GLboolean GLApiBase::glIsQueryFn(GLuint query) {
   return driver_->fn.glIsQueryFn(query);
 }
 
 GLboolean GLApiBase::glIsRenderbufferEXTFn(GLuint renderbuffer) {
   return driver_->fn.glIsRenderbufferEXTFn(renderbuffer);
@@ skipping 43 matching lines @@
 }
 
 void GLApiBase::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
   driver_->fn.glMatrixLoadfEXTFn(matrixMode, m);
 }
 
 void GLApiBase::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
   driver_->fn.glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
+void GLApiBase::glPathCommandsNVFn(GLuint path,
+                                   GLsizei numCommands,
+                                   const GLubyte* commands,
+                                   GLsizei numCoords,
+                                   GLenum coordType,
+                                   const GLvoid* coords) {
+  driver_->fn.glPathCommandsNVFn(path, numCommands, commands, numCoords,
+                                 coordType, coords);
+}
+
+void GLApiBase::glPathParameterfNVFn(GLuint path, GLenum pname, GLfloat value) {
+  driver_->fn.glPathParameterfNVFn(path, pname, value);
+}
+
+void GLApiBase::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
+  driver_->fn.glPathParameteriNVFn(path, pname, value);
+}
+
+void GLApiBase::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
+  driver_->fn.glPathStencilFuncNVFn(func, ref, mask);
+}
+
 void GLApiBase::glPauseTransformFeedbackFn(void) {
   driver_->fn.glPauseTransformFeedbackFn();
 }
 
 void GLApiBase::glPixelStoreiFn(GLenum pname, GLint param) {
   driver_->fn.glPixelStoreiFn(pname, param);
 }
 
 void GLApiBase::glPointParameteriFn(GLenum pname, GLint param) {
   driver_->fn.glPointParameteriFn(pname, param);
@@ skipping 141 matching lines @@
   driver_->fn.glShaderBinaryFn(n, shaders, binaryformat, binary, length);
 }
 
 void GLApiBase::glShaderSourceFn(GLuint shader,
                                  GLsizei count,
                                  const char* const* str,
                                  const GLint* length) {
   driver_->fn.glShaderSourceFn(shader, count, str, length);
 }
 
+void GLApiBase::glStencilFillPathNVFn(GLuint path,
+                                      GLenum fillMode,
+                                      GLuint mask) {
+  driver_->fn.glStencilFillPathNVFn(path, fillMode, mask);
+}
+
 void GLApiBase::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   driver_->fn.glStencilFuncFn(func, ref, mask);
 }
 
 void GLApiBase::glStencilFuncSeparateFn(GLenum face,
                                         GLenum func,
                                         GLint ref,
                                         GLuint mask) {
   driver_->fn.glStencilFuncSeparateFn(face, func, ref, mask);
 }
@@ skipping 10 matching lines @@
   driver_->fn.glStencilOpFn(fail, zfail, zpass);
 }
 
 void GLApiBase::glStencilOpSeparateFn(GLenum face,
                                       GLenum fail,
                                       GLenum zfail,
                                       GLenum zpass) {
   driver_->fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
+void GLApiBase::glStencilStrokePathNVFn(GLuint path,
+                                        GLint reference,
+                                        GLuint mask) {
+  driver_->fn.glStencilStrokePathNVFn(path, reference, mask);
+}
+
+void GLApiBase::glStencilThenCoverFillPathNVFn(GLuint path,
+                                               GLenum fillMode,
+                                               GLuint mask,
+                                               GLenum coverMode) {
+  driver_->fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
+}
+
+void GLApiBase::glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                 GLint reference,
+                                                 GLuint mask,
+                                                 GLenum coverMode) {
+  driver_->fn.glStencilThenCoverStrokePathNVFn(path, reference, mask,
+                                               coverMode);
+}
+
 GLboolean GLApiBase::glTestFenceAPPLEFn(GLuint fence) {
   return driver_->fn.glTestFenceAPPLEFn(fence);
 }
 
 GLboolean GLApiBase::glTestFenceNVFn(GLuint fence) {
   return driver_->fn.glTestFenceNVFn(fence);
 }
 
 void GLApiBase::glTexImage2DFn(GLenum target,
                                GLint level,
@@ skipping 776 matching lines @@
                                        GLint zoffset,
                                        GLint x,
                                        GLint y,
                                        GLsizei width,
                                        GLsizei height) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCopyTexSubImage3D")
   gl_api_->glCopyTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, x, y,
                                  width, height);
 }
 
+void TraceGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverFillPathNV")
+  gl_api_->glCoverFillPathNVFn(path, coverMode);
+}
+
+void TraceGLApi::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverStrokePathNV")
+  gl_api_->glCoverStrokePathNVFn(name, coverMode);
+}
+
 GLuint TraceGLApi::glCreateProgramFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCreateProgram")
   return gl_api_->glCreateProgramFn();
 }
 
 GLuint TraceGLApi::glCreateShaderFn(GLenum type) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCreateShader")
   return gl_api_->glCreateShaderFn(type);
 }
 
@@ skipping 16 matching lines @@
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteFencesNV")
   gl_api_->glDeleteFencesNVFn(n, fences);
 }
 
 void TraceGLApi::glDeleteFramebuffersEXTFn(GLsizei n,
                                            const GLuint* framebuffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteFramebuffersEXT")
   gl_api_->glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
+void TraceGLApi::glDeletePathsNVFn(GLuint path, GLsizei range) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeletePathsNV")
+  gl_api_->glDeletePathsNVFn(path, range);
+}
+
 void TraceGLApi::glDeleteProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteProgram")
   gl_api_->glDeleteProgramFn(program);
 }
 
 void TraceGLApi::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteQueries")
   gl_api_->glDeleteQueriesFn(n, ids);
 }
 
@@ skipping 270 matching lines @@
 void TraceGLApi::glGenFencesNVFn(GLsizei n, GLuint* fences) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenFencesNV")
   gl_api_->glGenFencesNVFn(n, fences);
 }
 
 void TraceGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenFramebuffersEXT")
   gl_api_->glGenFramebuffersEXTFn(n, framebuffers);
 }
 
+GLuint TraceGLApi::glGenPathsNVFn(GLsizei range) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenPathsNV")
+  return gl_api_->glGenPathsNVFn(range);
+}
+
 void TraceGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenQueries")
   gl_api_->glGenQueriesFn(n, ids);
 }
 
 void TraceGLApi::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenRenderbuffersEXT")
   gl_api_->glGenRenderbuffersEXTFn(n, renderbuffers);
 }
 
@@ skipping 458 matching lines @@
 GLboolean TraceGLApi::glIsFenceNVFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFenceNV")
   return gl_api_->glIsFenceNVFn(fence);
 }
 
 GLboolean TraceGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFramebufferEXT")
   return gl_api_->glIsFramebufferEXTFn(framebuffer);
 }
 
+GLboolean TraceGLApi::glIsPathNVFn(GLuint path) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsPathNV")
+  return gl_api_->glIsPathNVFn(path);
+}
+
 GLboolean TraceGLApi::glIsProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsProgram")
   return gl_api_->glIsProgramFn(program);
 }
 
 GLboolean TraceGLApi::glIsQueryFn(GLuint query) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsQuery")
   return gl_api_->glIsQueryFn(query);
 }
 
@@ skipping 58 matching lines @@
 void TraceGLApi::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMatrixLoadfEXT")
   gl_api_->glMatrixLoadfEXTFn(matrixMode, m);
 }
 
 void TraceGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMatrixLoadIdentityEXT")
   gl_api_->glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
+void TraceGLApi::glPathCommandsNVFn(GLuint path,
+                                    GLsizei numCommands,
+                                    const GLubyte* commands,
+                                    GLsizei numCoords,
+                                    GLenum coordType,
+                                    const GLvoid* coords) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathCommandsNV")
+  gl_api_->glPathCommandsNVFn(path, numCommands, commands, numCoords, coordType,
+                              coords);
+}
+
+void TraceGLApi::glPathParameterfNVFn(GLuint path,
+                                      GLenum pname,
+                                      GLfloat value) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathParameterfNV")
+  gl_api_->glPathParameterfNVFn(path, pname, value);
+}
+
+void TraceGLApi::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathParameteriNV")
+  gl_api_->glPathParameteriNVFn(path, pname, value);
+}
+
+void TraceGLApi::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathStencilFuncNV")
+  gl_api_->glPathStencilFuncNVFn(func, ref, mask);
+}
+
 void TraceGLApi::glPauseTransformFeedbackFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPauseTransformFeedback")
   gl_api_->glPauseTransformFeedbackFn();
 }
 
 void TraceGLApi::glPixelStoreiFn(GLenum pname, GLint param) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPixelStorei")
   gl_api_->glPixelStoreiFn(pname, param);
 }
 
@@ skipping 173 matching lines @@
 }
 
 void TraceGLApi::glShaderSourceFn(GLuint shader,
                                   GLsizei count,
                                   const char* const* str,
                                   const GLint* length) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glShaderSource")
   gl_api_->glShaderSourceFn(shader, count, str, length);
 }
 
+void TraceGLApi::glStencilFillPathNVFn(GLuint path,
+                                       GLenum fillMode,
+                                       GLuint mask) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFillPathNV")
+  gl_api_->glStencilFillPathNVFn(path, fillMode, mask);
+}
+
 void TraceGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFunc")
   gl_api_->glStencilFuncFn(func, ref, mask);
 }
 
 void TraceGLApi::glStencilFuncSeparateFn(GLenum face,
                                          GLenum func,
                                          GLint ref,
                                          GLuint mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFuncSeparate")
@@ skipping 16 matching lines @@
 }
 
 void TraceGLApi::glStencilOpSeparateFn(GLenum face,
                                        GLenum fail,
                                        GLenum zfail,
                                        GLenum zpass) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilOpSeparate")
   gl_api_->glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
+void TraceGLApi::glStencilStrokePathNVFn(GLuint path,
+                                         GLint reference,
+                                         GLuint mask) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilStrokePathNV")
+  gl_api_->glStencilStrokePathNVFn(path, reference, mask);
+}
+
+void TraceGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
+                                                GLenum fillMode,
+                                                GLuint mask,
+                                                GLenum coverMode) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::glStencilThenCoverFillPathNV")
+  gl_api_->glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
+}
+
+void TraceGLApi::glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                  GLint reference,
+                                                  GLuint mask,
+                                                  GLenum coverMode) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::glStencilThenCoverStrokePathNV")
+  gl_api_->glStencilThenCoverStrokePathNVFn(path, reference, mask, coverMode);
+}
+
 GLboolean TraceGLApi::glTestFenceAPPLEFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTestFenceAPPLE")
   return gl_api_->glTestFenceAPPLEFn(fence);
 }
 
 GLboolean TraceGLApi::glTestFenceNVFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTestFenceNV")
   return gl_api_->glTestFenceNVFn(fence);
 }
 
@@ skipping 881 matching lines @@
                                            GLint x,
                                            GLint y,
                                            GLsizei width,
                                            GLsizei height) {
   NOTREACHED()
       << "Trying to call glCopyTexSubImage3D() without current GL context";
   LOG(ERROR)
       << "Trying to call glCopyTexSubImage3D() without current GL context";
 }
 
+void NoContextGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+  NOTREACHED()
+      << "Trying to call glCoverFillPathNV() without current GL context";
+  LOG(ERROR) << "Trying to call glCoverFillPathNV() without current GL context";
+}
+
+void NoContextGLApi::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+  NOTREACHED()
+      << "Trying to call glCoverStrokePathNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glCoverStrokePathNV() without current GL context";
+}
+
 GLuint NoContextGLApi::glCreateProgramFn(void) {
   NOTREACHED() << "Trying to call glCreateProgram() without current GL context";
   LOG(ERROR) << "Trying to call glCreateProgram() without current GL context";
   return 0U;
 }
 
 GLuint NoContextGLApi::glCreateShaderFn(GLenum type) {
   NOTREACHED() << "Trying to call glCreateShader() without current GL context";
   LOG(ERROR) << "Trying to call glCreateShader() without current GL context";
   return 0U;
@@ skipping 25 matching lines @@
 }
 
 void NoContextGLApi::glDeleteFramebuffersEXTFn(GLsizei n,
                                                const GLuint* framebuffers) {
   NOTREACHED()
       << "Trying to call glDeleteFramebuffersEXT() without current GL context";
   LOG(ERROR)
       << "Trying to call glDeleteFramebuffersEXT() without current GL context";
 }
 
+void NoContextGLApi::glDeletePathsNVFn(GLuint path, GLsizei range) {
+  NOTREACHED() << "Trying to call glDeletePathsNV() without current GL context";
+  LOG(ERROR) << "Trying to call glDeletePathsNV() without current GL context";
+}
+
 void NoContextGLApi::glDeleteProgramFn(GLuint program) {
   NOTREACHED() << "Trying to call glDeleteProgram() without current GL context";
   LOG(ERROR) << "Trying to call glDeleteProgram() without current GL context";
 }
 
 void NoContextGLApi::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
   NOTREACHED() << "Trying to call glDeleteQueries() without current GL context";
   LOG(ERROR) << "Trying to call glDeleteQueries() without current GL context";
 }
 
@@ skipping 308 matching lines @@
   LOG(ERROR) << "Trying to call glGenFencesNV() without current GL context";
 }
 
 void NoContextGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
   NOTREACHED()
       << "Trying to call glGenFramebuffersEXT() without current GL context";
   LOG(ERROR)
       << "Trying to call glGenFramebuffersEXT() without current GL context";
 }
 
+GLuint NoContextGLApi::glGenPathsNVFn(GLsizei range) {
+  NOTREACHED() << "Trying to call glGenPathsNV() without current GL context";
+  LOG(ERROR) << "Trying to call glGenPathsNV() without current GL context";
+  return 0U;
+}
+
 void NoContextGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
   NOTREACHED() << "Trying to call glGenQueries() without current GL context";
   LOG(ERROR) << "Trying to call glGenQueries() without current GL context";
 }
 
 void NoContextGLApi::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
   NOTREACHED()
       << "Trying to call glGenRenderbuffersEXT() without current GL context";
   LOG(ERROR)
       << "Trying to call glGenRenderbuffersEXT() without current GL context";
@@ skipping 555 matching lines @@
 }
 
 GLboolean NoContextGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
   NOTREACHED()
       << "Trying to call glIsFramebufferEXT() without current GL context";
   LOG(ERROR)
       << "Trying to call glIsFramebufferEXT() without current GL context";
   return GL_FALSE;
 }
 
+GLboolean NoContextGLApi::glIsPathNVFn(GLuint path) {
+  NOTREACHED() << "Trying to call glIsPathNV() without current GL context";
+  LOG(ERROR) << "Trying to call glIsPathNV() without current GL context";
+  return GL_FALSE;
+}
+
 GLboolean NoContextGLApi::glIsProgramFn(GLuint program) {
   NOTREACHED() << "Trying to call glIsProgram() without current GL context";
   LOG(ERROR) << "Trying to call glIsProgram() without current GL context";
   return GL_FALSE;
 }
 
 GLboolean NoContextGLApi::glIsQueryFn(GLuint query) {
   NOTREACHED() << "Trying to call glIsQuery() without current GL context";
   LOG(ERROR) << "Trying to call glIsQuery() without current GL context";
   return GL_FALSE;
@@ skipping 79 matching lines @@
   LOG(ERROR) << "Trying to call glMatrixLoadfEXT() without current GL context";
 }
 
 void NoContextGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
   NOTREACHED()
       << "Trying to call glMatrixLoadIdentityEXT() without current GL context";
   LOG(ERROR)
       << "Trying to call glMatrixLoadIdentityEXT() without current GL context";
 }
 
+void NoContextGLApi::glPathCommandsNVFn(GLuint path,
+                                        GLsizei numCommands,
+                                        const GLubyte* commands,
+                                        GLsizei numCoords,
+                                        GLenum coordType,
+                                        const GLvoid* coords) {
+  NOTREACHED()
+      << "Trying to call glPathCommandsNV() without current GL context";
+  LOG(ERROR) << "Trying to call glPathCommandsNV() without current GL context";
+}
+
+void NoContextGLApi::glPathParameterfNVFn(GLuint path,
+                                          GLenum pname,
+                                          GLfloat value) {
+  NOTREACHED()
+      << "Trying to call glPathParameterfNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glPathParameterfNV() without current GL context";
+}
+
+void NoContextGLApi::glPathParameteriNVFn(GLuint path,
+                                          GLenum pname,
+                                          GLint value) {
+  NOTREACHED()
+      << "Trying to call glPathParameteriNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glPathParameteriNV() without current GL context";
+}
+
+void NoContextGLApi::glPathStencilFuncNVFn(GLenum func,
+                                           GLint ref,
+                                           GLuint mask) {
+  NOTREACHED()
+      << "Trying to call glPathStencilFuncNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glPathStencilFuncNV() without current GL context";
+}
+
 void NoContextGLApi::glPauseTransformFeedbackFn(void) {
   NOTREACHED()
       << "Trying to call glPauseTransformFeedback() without current GL context";
   LOG(ERROR)
       << "Trying to call glPauseTransformFeedback() without current GL context";
 }
 
 void NoContextGLApi::glPixelStoreiFn(GLenum pname, GLint param) {
   NOTREACHED() << "Trying to call glPixelStorei() without current GL context";
   LOG(ERROR) << "Trying to call glPixelStorei() without current GL context";
@@ skipping 204 matching lines @@
 }
 
 void NoContextGLApi::glShaderSourceFn(GLuint shader,
                                       GLsizei count,
                                       const char* const* str,
                                       const GLint* length) {
   NOTREACHED() << "Trying to call glShaderSource() without current GL context";
   LOG(ERROR) << "Trying to call glShaderSource() without current GL context";
 }
 
+void NoContextGLApi::glStencilFillPathNVFn(GLuint path,
+                                           GLenum fillMode,
+                                           GLuint mask) {
+  NOTREACHED()
+      << "Trying to call glStencilFillPathNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glStencilFillPathNV() without current GL context";
+}
+
 void NoContextGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   NOTREACHED() << "Trying to call glStencilFunc() without current GL context";
   LOG(ERROR) << "Trying to call glStencilFunc() without current GL context";
 }
 
 void NoContextGLApi::glStencilFuncSeparateFn(GLenum face,
                                              GLenum func,
                                              GLint ref,
                                              GLuint mask) {
   NOTREACHED()
@@ skipping 22 matching lines @@
 void NoContextGLApi::glStencilOpSeparateFn(GLenum face,
                                            GLenum fail,
                                            GLenum zfail,
                                            GLenum zpass) {
   NOTREACHED()
       << "Trying to call glStencilOpSeparate() without current GL context";
   LOG(ERROR)
       << "Trying to call glStencilOpSeparate() without current GL context";
 }
 
+void NoContextGLApi::glStencilStrokePathNVFn(GLuint path,
+                                             GLint reference,
+                                             GLuint mask) {
+  NOTREACHED()
+      << "Trying to call glStencilStrokePathNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glStencilStrokePathNV() without current GL context";
+}
+
+void NoContextGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
+                                                    GLenum fillMode,
+                                                    GLuint mask,
+                                                    GLenum coverMode) {
+  NOTREACHED() << "Trying to call glStencilThenCoverFillPathNV() without "
+                  "current GL context";
+  LOG(ERROR) << "Trying to call glStencilThenCoverFillPathNV() without current "
+                "GL context";
+}
+
+void NoContextGLApi::glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                      GLint reference,
+                                                      GLuint mask,
+                                                      GLenum coverMode) {
+  NOTREACHED() << "Trying to call glStencilThenCoverStrokePathNV() without "
+                  "current GL context";
+  LOG(ERROR) << "Trying to call glStencilThenCoverStrokePathNV() without "
+                "current GL context";
+}
+
 GLboolean NoContextGLApi::glTestFenceAPPLEFn(GLuint fence) {
   NOTREACHED()
       << "Trying to call glTestFenceAPPLE() without current GL context";
   LOG(ERROR) << "Trying to call glTestFenceAPPLE() without current GL context";
   return GL_FALSE;
 }
 
 GLboolean NoContextGLApi::glTestFenceNVFn(GLuint fence) {
   NOTREACHED() << "Trying to call glTestFenceNV() without current GL context";
   LOG(ERROR) << "Trying to call glTestFenceNV() without current GL context";
@@ skipping 524 matching lines @@
 
 GLenum NoContextGLApi::glWaitSyncFn(GLsync sync,
                                     GLbitfield flags,
                                     GLuint64 timeout) {
   NOTREACHED() << "Trying to call glWaitSync() without current GL context";
   LOG(ERROR) << "Trying to call glWaitSync() without current GL context";
   return static_cast<GLenum>(0);
 }
 
 }  // namespace gfx