command_buffer: Support instanced path rendering in gpu command buffer

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 77 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.glCoverFillPathInstancedNVFn = 0;
   fn.glCoverFillPathNVFn = 0;
+  fn.glCoverStrokePathInstancedNVFn = 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;
@@ skipping 213 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.glStencilFillPathInstancedNVFn = 0;
   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.glStencilStrokePathInstancedNVFn = 0;
   fn.glStencilStrokePathNVFn = 0;
+  fn.glStencilThenCoverFillPathInstancedNVFn = 0;
   fn.glStencilThenCoverFillPathNVFn = 0;
+  fn.glStencilThenCoverStrokePathInstancedNVFn = 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"));
@@ skipping 387 matching lines @@
     fn.glCopyBufferSubDataFn = reinterpret_cast<glCopyBufferSubDataProc>(
         GetGLProcAddress("glCopyBufferSubData"));
   }
 
   debug_fn.glCopyTexSubImage3DFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glCopyTexSubImage3DFn = reinterpret_cast<glCopyTexSubImage3DProc>(
         GetGLProcAddress("glCopyTexSubImage3D"));
   }
 
+  debug_fn.glCoverFillPathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverFillPathInstancedNVFn =
+        reinterpret_cast<glCoverFillPathInstancedNVProc>(
+            GetGLProcAddress("glCoverFillPathInstancedNV"));
+  }
+
   debug_fn.glCoverFillPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glCoverFillPathNVFn = reinterpret_cast<glCoverFillPathNVProc>(
         GetGLProcAddress("glCoverFillPathNV"));
   }
 
+  debug_fn.glCoverStrokePathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverStrokePathInstancedNVFn =
+        reinterpret_cast<glCoverStrokePathInstancedNVProc>(
+            GetGLProcAddress("glCoverStrokePathInstancedNV"));
+  }
+
   debug_fn.glCoverStrokePathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glCoverStrokePathNVFn = reinterpret_cast<glCoverStrokePathNVProc>(
         GetGLProcAddress("glCoverStrokePathNV"));
   }
 
   debug_fn.glDeleteFencesAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glDeleteFencesAPPLEFn = reinterpret_cast<glDeleteFencesAPPLEProc>(
         GetGLProcAddress("glDeleteFencesAPPLE"));
@@ skipping 882 matching lines @@
     fn.glSetFenceNVFn =
         reinterpret_cast<glSetFenceNVProc>(GetGLProcAddress("glSetFenceNV"));
   }
 
   debug_fn.glShaderBinaryFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
     fn.glShaderBinaryFn = reinterpret_cast<glShaderBinaryProc>(
         GetGLProcAddress("glShaderBinary"));
   }
 
+  debug_fn.glStencilFillPathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilFillPathInstancedNVFn =
+        reinterpret_cast<glStencilFillPathInstancedNVProc>(
+            GetGLProcAddress("glStencilFillPathInstancedNV"));
+  }
+
   debug_fn.glStencilFillPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilFillPathNVFn = reinterpret_cast<glStencilFillPathNVProc>(
         GetGLProcAddress("glStencilFillPathNV"));
   }
 
+  debug_fn.glStencilStrokePathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilStrokePathInstancedNVFn =
+        reinterpret_cast<glStencilStrokePathInstancedNVProc>(
+            GetGLProcAddress("glStencilStrokePathInstancedNV"));
+  }
+
   debug_fn.glStencilStrokePathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilStrokePathNVFn = reinterpret_cast<glStencilStrokePathNVProc>(
         GetGLProcAddress("glStencilStrokePathNV"));
   }
 
+  debug_fn.glStencilThenCoverFillPathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverFillPathInstancedNVFn =
+        reinterpret_cast<glStencilThenCoverFillPathInstancedNVProc>(
+            GetGLProcAddress("glStencilThenCoverFillPathInstancedNV"));
+  }
+
   debug_fn.glStencilThenCoverFillPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilThenCoverFillPathNVFn =
         reinterpret_cast<glStencilThenCoverFillPathNVProc>(
             GetGLProcAddress("glStencilThenCoverFillPathNV"));
   }
 
+  debug_fn.glStencilThenCoverStrokePathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverStrokePathInstancedNVFn =
+        reinterpret_cast<glStencilThenCoverStrokePathInstancedNVProc>(
+            GetGLProcAddress("glStencilThenCoverStrokePathInstancedNV"));
+  }
+
   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>(
@@ skipping 702 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_glCoverFillPathInstancedNV(GLsizei numPaths,
+                                 GLenum pathNameType,
+                                 const void* paths,
+                                 GLuint pathBase,
+                                 GLenum coverMode,
+                                 GLenum transformType,
+                                 const GLfloat* transformValues) {
+  GL_SERVICE_LOG("glCoverFillPathInstancedNV"
+                 << "(" << numPaths << ", "
+                 << GLEnums::GetStringEnum(pathNameType) << ", "
+                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
+                 << GLEnums::GetStringEnum(coverMode) << ", "
+                 << GLEnums::GetStringEnum(transformType) << ", "
+                 << static_cast<const void*>(transformValues) << ")");
+  g_driver_gl.debug_fn.glCoverFillPathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, coverMode, transformType,
+      transformValues);
+}
+
 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_glCoverStrokePathInstancedNV(GLsizei numPaths,
+                                   GLenum pathNameType,
+                                   const void* paths,
+                                   GLuint pathBase,
+                                   GLenum coverMode,
+                                   GLenum transformType,
+                                   const GLfloat* transformValues) {
+  GL_SERVICE_LOG("glCoverStrokePathInstancedNV"
+                 << "(" << numPaths << ", "
+                 << GLEnums::GetStringEnum(pathNameType) << ", "
+                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
+                 << GLEnums::GetStringEnum(coverMode) << ", "
+                 << GLEnums::GetStringEnum(transformType) << ", "
+                 << static_cast<const void*>(transformValues) << ")");
+  g_driver_gl.debug_fn.glCoverStrokePathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, coverMode, transformType,
+      transformValues);
+}
+
 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"
@@ skipping 1604 matching lines @@
         } else {
           GL_SERVICE_LOG("  " << ii << ": ---\n" << str[ii] << "\n---");
         }
       } else {
         GL_SERVICE_LOG("  " << ii << ": NULL");
       }
     }
   });
 }
 
+static void GL_BINDING_CALL
+Debug_glStencilFillPathInstancedNV(GLsizei numPaths,
+                                   GLenum pathNameType,
+                                   const void* paths,
+                                   GLuint pathBase,
+                                   GLenum fillMode,
+                                   GLuint mask,
+                                   GLenum transformType,
+                                   const GLfloat* transformValues) {
+  GL_SERVICE_LOG("glStencilFillPathInstancedNV"
+                 << "(" << numPaths << ", "
+                 << GLEnums::GetStringEnum(pathNameType) << ", "
+                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
+                 << GLEnums::GetStringEnum(fillMode) << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(transformType) << ", "
+                 << static_cast<const void*>(transformValues) << ")");
+  g_driver_gl.debug_fn.glStencilFillPathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType,
+      transformValues);
+}
+
 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,
@@ skipping 44 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_glStencilStrokePathInstancedNV(GLsizei numPaths,
+                                     GLenum pathNameType,
+                                     const void* paths,
+                                     GLuint pathBase,
+                                     GLint ref,
+                                     GLuint mask,
+                                     GLenum transformType,
+                                     const GLfloat* transformValues) {
+  GL_SERVICE_LOG(
+      "glStencilStrokePathInstancedNV"
+      << "(" << numPaths << ", " << GLEnums::GetStringEnum(pathNameType) << ", "
+      << static_cast<const void*>(paths) << ", " << pathBase << ", " << ref
+      << ", " << mask << ", " << GLEnums::GetStringEnum(transformType) << ", "
+      << static_cast<const void*>(transformValues) << ")");
+  g_driver_gl.debug_fn.glStencilStrokePathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, ref, mask, transformType,
+      transformValues);
+}
+
 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_glStencilThenCoverFillPathInstancedNV(GLsizei numPaths,
+                                            GLenum pathNameType,
+                                            const void* paths,
+                                            GLuint pathBase,
+                                            GLenum fillMode,
+                                            GLuint mask,
+                                            GLenum coverMode,
+                                            GLenum transformType,
+                                            const GLfloat* transformValues) {
+  GL_SERVICE_LOG("glStencilThenCoverFillPathInstancedNV"
+                 << "(" << numPaths << ", "
+                 << GLEnums::GetStringEnum(pathNameType) << ", "
+                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
+                 << GLEnums::GetStringEnum(fillMode) << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(coverMode) << ", "
+                 << GLEnums::GetStringEnum(transformType) << ", "
+                 << static_cast<const void*>(transformValues) << ")");
+  g_driver_gl.debug_fn.glStencilThenCoverFillPathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+      transformType, transformValues);
+}
+
+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_glStencilThenCoverStrokePathInstancedNV(GLsizei numPaths,
+                                              GLenum pathNameType,
+                                              const void* paths,
+                                              GLuint pathBase,
+                                              GLint ref,
+                                              GLuint mask,
+                                              GLenum coverMode,
+                                              GLenum transformType,
+                                              const GLfloat* transformValues) {
+  GL_SERVICE_LOG(
+      "glStencilThenCoverStrokePathInstancedNV"
+      << "(" << numPaths << ", " << GLEnums::GetStringEnum(pathNameType) << ", "
+      << static_cast<const void*>(paths) << ", " << pathBase << ", " << ref
+      << ", " << mask << ", " << GLEnums::GetStringEnum(coverMode) << ", "
+      << GLEnums::GetStringEnum(transformType) << ", "
+      << static_cast<const void*>(transformValues) << ")");
+  g_driver_gl.debug_fn.glStencilThenCoverStrokePathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
+      transformType, transformValues);
+}
+
+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);
 }
@@ skipping 861 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.glCoverFillPathInstancedNVFn) {
+    debug_fn.glCoverFillPathInstancedNVFn = fn.glCoverFillPathInstancedNVFn;
+    fn.glCoverFillPathInstancedNVFn = Debug_glCoverFillPathInstancedNV;
+  }
   if (!debug_fn.glCoverFillPathNVFn) {
     debug_fn.glCoverFillPathNVFn = fn.glCoverFillPathNVFn;
     fn.glCoverFillPathNVFn = Debug_glCoverFillPathNV;
   }
+  if (!debug_fn.glCoverStrokePathInstancedNVFn) {
+    debug_fn.glCoverStrokePathInstancedNVFn = fn.glCoverStrokePathInstancedNVFn;
+    fn.glCoverStrokePathInstancedNVFn = Debug_glCoverStrokePathInstancedNV;
+  }
   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;
@@ skipping 697 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.glStencilFillPathInstancedNVFn) {
+    debug_fn.glStencilFillPathInstancedNVFn = fn.glStencilFillPathInstancedNVFn;
+    fn.glStencilFillPathInstancedNVFn = Debug_glStencilFillPathInstancedNV;
+  }
   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.glStencilStrokePathInstancedNVFn) {
+    debug_fn.glStencilStrokePathInstancedNVFn =
+        fn.glStencilStrokePathInstancedNVFn;
+    fn.glStencilStrokePathInstancedNVFn = Debug_glStencilStrokePathInstancedNV;
+  }
   if (!debug_fn.glStencilStrokePathNVFn) {
     debug_fn.glStencilStrokePathNVFn = fn.glStencilStrokePathNVFn;
     fn.glStencilStrokePathNVFn = Debug_glStencilStrokePathNV;
   }
+  if (!debug_fn.glStencilThenCoverFillPathInstancedNVFn) {
+    debug_fn.glStencilThenCoverFillPathInstancedNVFn =
+        fn.glStencilThenCoverFillPathInstancedNVFn;
+    fn.glStencilThenCoverFillPathInstancedNVFn =
+        Debug_glStencilThenCoverFillPathInstancedNV;
+  }
   if (!debug_fn.glStencilThenCoverFillPathNVFn) {
     debug_fn.glStencilThenCoverFillPathNVFn = fn.glStencilThenCoverFillPathNVFn;
     fn.glStencilThenCoverFillPathNVFn = Debug_glStencilThenCoverFillPathNV;
   }
+  if (!debug_fn.glStencilThenCoverStrokePathInstancedNVFn) {
+    debug_fn.glStencilThenCoverStrokePathInstancedNVFn =
+        fn.glStencilThenCoverStrokePathInstancedNVFn;
+    fn.glStencilThenCoverStrokePathInstancedNVFn =
+        Debug_glStencilThenCoverStrokePathInstancedNV;
+  }
   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) {
@@ skipping 595 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::glCoverFillPathInstancedNVFn(GLsizei numPaths,
+                                             GLenum pathNameType,
+                                             const void* paths,
+                                             GLuint pathBase,
+                                             GLenum coverMode,
+                                             GLenum transformType,
+                                             const GLfloat* transformValues) {
+  driver_->fn.glCoverFillPathInstancedNVFn(numPaths, pathNameType, paths,
+                                           pathBase, coverMode, transformType,
+                                           transformValues);
+}
+
 void GLApiBase::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
   driver_->fn.glCoverFillPathNVFn(path, coverMode);
 }
 
+void GLApiBase::glCoverStrokePathInstancedNVFn(GLsizei numPaths,
+                                               GLenum pathNameType,
+                                               const void* paths,
+                                               GLuint pathBase,
+                                               GLenum coverMode,
+                                               GLenum transformType,
+                                               const GLfloat* transformValues) {
+  driver_->fn.glCoverStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+                                             pathBase, coverMode, transformType,
+                                             transformValues);
+}
+
 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);
@@ skipping 910 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::glStencilFillPathInstancedNVFn(GLsizei numPaths,
+                                               GLenum pathNameType,
+                                               const void* paths,
+                                               GLuint pathBase,
+                                               GLenum fillMode,
+                                               GLuint mask,
+                                               GLenum transformType,
+                                               const GLfloat* transformValues) {
+  driver_->fn.glStencilFillPathInstancedNVFn(numPaths, pathNameType, paths,
+                                             pathBase, fillMode, mask,
+                                             transformType, transformValues);
+}
+
 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);
 }
 
@@ skipping 16 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::glStencilStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  driver_->fn.glStencilStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+                                               pathBase, ref, mask,
+                                               transformType, transformValues);
+}
+
 void GLApiBase::glStencilStrokePathNVFn(GLuint path,
                                         GLint reference,
                                         GLuint mask) {
   driver_->fn.glStencilStrokePathNVFn(path, reference, mask);
 }
 
+void GLApiBase::glStencilThenCoverFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  driver_->fn.glStencilThenCoverFillPathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+      transformType, transformValues);
+}
+
 void GLApiBase::glStencilThenCoverFillPathNVFn(GLuint path,
                                                GLenum fillMode,
                                                GLuint mask,
                                                GLenum coverMode) {
   driver_->fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
 }
 
+void GLApiBase::glStencilThenCoverStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  driver_->fn.glStencilThenCoverStrokePathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
+      transformType, transformValues);
+}
+
 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);
@@ skipping 790 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::glCoverFillPathInstancedNVFn(GLsizei numPaths,
+                                              GLenum pathNameType,
+                                              const void* paths,
+                                              GLuint pathBase,
+                                              GLenum coverMode,
+                                              GLenum transformType,
+                                              const GLfloat* transformValues) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverFillPathInstancedNV")
+  gl_api_->glCoverFillPathInstancedNVFn(numPaths, pathNameType, paths, pathBase,
+                                        coverMode, transformType,
+                                        transformValues);
+}
+
 void TraceGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverFillPathNV")
   gl_api_->glCoverFillPathNVFn(path, coverMode);
 }
 
+void TraceGLApi::glCoverStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::glCoverStrokePathInstancedNV")
+  gl_api_->glCoverStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+                                          pathBase, coverMode, transformType,
+                                          transformValues);
+}
+
 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();
 }
 
@@ skipping 1103 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::glStencilFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::glStencilFillPathInstancedNV")
+  gl_api_->glStencilFillPathInstancedNVFn(numPaths, pathNameType, paths,
+                                          pathBase, fillMode, mask,
+                                          transformType, transformValues);
+}
+
 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);
@@ skipping 23 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::glStencilStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::glStencilStrokePathInstancedNV")
+  gl_api_->glStencilStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+                                            pathBase, ref, mask, transformType,
+                                            transformValues);
+}
+
 void TraceGLApi::glStencilStrokePathNVFn(GLuint path,
                                          GLint reference,
                                          GLuint mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilStrokePathNV")
   gl_api_->glStencilStrokePathNVFn(path, reference, mask);
 }
 
+void TraceGLApi::glStencilThenCoverFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  TRACE_EVENT_BINARY_EFFICIENT0(
+      "gpu", "TraceGLAPI::glStencilThenCoverFillPathInstancedNV")
+  gl_api_->glStencilThenCoverFillPathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+      transformType, transformValues);
+}
+
 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::glStencilThenCoverStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  TRACE_EVENT_BINARY_EFFICIENT0(
+      "gpu", "TraceGLAPI::glStencilThenCoverStrokePathInstancedNV")
+  gl_api_->glStencilThenCoverStrokePathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
+      transformType, transformValues);
+}
+
 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) {
@@ skipping 897 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::glCoverFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  NOTREACHED() << "Trying to call glCoverFillPathInstancedNV() without current "
+                  "GL context";
+  LOG(ERROR) << "Trying to call glCoverFillPathInstancedNV() 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::glCoverStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  NOTREACHED() << "Trying to call glCoverStrokePathInstancedNV() without "
+                  "current GL context";
+  LOG(ERROR) << "Trying to call glCoverStrokePathInstancedNV() 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";
@@ skipping 1313 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::glStencilFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  NOTREACHED() << "Trying to call glStencilFillPathInstancedNV() without "
+                  "current GL context";
+  LOG(ERROR) << "Trying to call glStencilFillPathInstancedNV() 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) {
@@ skipping 31 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::glStencilStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  NOTREACHED() << "Trying to call glStencilStrokePathInstancedNV() without "
+                  "current GL context";
+  LOG(ERROR) << "Trying to call glStencilStrokePathInstancedNV() 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::glStencilThenCoverFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  NOTREACHED() << "Trying to call glStencilThenCoverFillPathInstancedNV() "
+                  "without current GL context";
+  LOG(ERROR) << "Trying to call glStencilThenCoverFillPathInstancedNV() "
+                "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::glStencilThenCoverStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  NOTREACHED() << "Trying to call glStencilThenCoverStrokePathInstancedNV() "
+                  "without current GL context";
+  LOG(ERROR) << "Trying to call glStencilThenCoverStrokePathInstancedNV() "
+                "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";
 }
 
@@ skipping 534 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