command_buffer: Support instanced path rendering in gpu command buffer

ui/gl/gl_bindings_autogen_gl.cc

Index: ui/gl/gl_bindings_autogen_gl.cc
diff --git a/ui/gl/gl_bindings_autogen_gl.cc b/ui/gl/gl_bindings_autogen_gl.cc
index 2917d993b9680bd9362a4032d7fb3a1218dba030..8c8f8a271d3d160cd709ec2605a18fd6ad5b80b8 100644
--- a/ui/gl/gl_bindings_autogen_gl.cc
+++ b/ui/gl/gl_bindings_autogen_gl.cc
@@ -95,7 +95,9 @@ void DriverGL::InitializeStaticBindings() {
   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"));
@@ -329,6 +331,7 @@ void DriverGL::InitializeStaticBindings() {
   fn.glShaderBinaryFn = 0;
   fn.glShaderSourceFn =
       reinterpret_cast<glShaderSourceProc>(GetGLProcAddress("glShaderSource"));
+  fn.glStencilFillPathInstancedNVFn = 0;
   fn.glStencilFillPathNVFn = 0;
   fn.glStencilFuncFn =
       reinterpret_cast<glStencilFuncProc>(GetGLProcAddress("glStencilFunc"));
@@ -342,8 +345,11 @@ void DriverGL::InitializeStaticBindings() {
       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;
@@ -788,6 +794,14 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glCopyTexSubImage3DFn);
   }
 
+  debug_fn.glCoverFillPathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverFillPathInstancedNVFn =
+        reinterpret_cast<glCoverFillPathInstancedNVProc>(
+            GetGLProcAddress("glCoverFillPathInstancedNV"));
+    DCHECK(fn.glCoverFillPathInstancedNVFn);
+  }
+
   debug_fn.glCoverFillPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glCoverFillPathNVFn = reinterpret_cast<glCoverFillPathNVProc>(
@@ -795,6 +809,14 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glCoverFillPathNVFn);
   }
 
+  debug_fn.glCoverStrokePathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverStrokePathInstancedNVFn =
+        reinterpret_cast<glCoverStrokePathInstancedNVProc>(
+            GetGLProcAddress("glCoverStrokePathInstancedNV"));
+    DCHECK(fn.glCoverStrokePathInstancedNVFn);
+  }
+
   debug_fn.glCoverStrokePathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glCoverStrokePathNVFn = reinterpret_cast<glCoverStrokePathNVProc>(
@@ -1859,6 +1881,14 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glShaderBinaryFn);
   }
 
+  debug_fn.glStencilFillPathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilFillPathInstancedNVFn =
+        reinterpret_cast<glStencilFillPathInstancedNVProc>(
+            GetGLProcAddress("glStencilFillPathInstancedNV"));
+    DCHECK(fn.glStencilFillPathInstancedNVFn);
+  }
+
   debug_fn.glStencilFillPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilFillPathNVFn = reinterpret_cast<glStencilFillPathNVProc>(
@@ -1866,6 +1896,14 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glStencilFillPathNVFn);
   }
 
+  debug_fn.glStencilStrokePathInstancedNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilStrokePathInstancedNVFn =
+        reinterpret_cast<glStencilStrokePathInstancedNVProc>(
+            GetGLProcAddress("glStencilStrokePathInstancedNV"));
+    DCHECK(fn.glStencilStrokePathInstancedNVFn);
+  }
+
   debug_fn.glStencilStrokePathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilStrokePathNVFn = reinterpret_cast<glStencilStrokePathNVProc>(
@@ -1873,6 +1911,13 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glStencilStrokePathNVFn);
   }
 
+  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 =
@@ -1880,6 +1925,13 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             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 =
@@ -2636,6 +2688,26 @@ static void GL_BINDING_CALL Debug_glCopyTexSubImage3D(GLenum target,
                                              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"
@@ -2644,6 +2716,26 @@ static void GL_BINDING_CALL Debug_glCoverFillPathNV(GLuint path,
   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"
@@ -4268,6 +4360,27 @@ static void GL_BINDING_CALL Debug_glShaderSource(GLuint shader,
   });
 }
 
+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) {
@@ -4332,6 +4445,26 @@ static void GL_BINDING_CALL Debug_glStencilOpSeparate(GLenum face,
   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) {
@@ -4341,6 +4474,29 @@ static void GL_BINDING_CALL Debug_glStencilStrokePathNV(GLuint path,
 }
 
 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,
@@ -4354,6 +4510,28 @@ Debug_glStencilThenCoverFillPathNV(GLuint path,
 }
 
 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,
@@ -5235,10 +5413,18 @@ void DriverGL::InitializeDebugBindings() {
     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;
@@ -5956,6 +6142,10 @@ void DriverGL::InitializeDebugBindings() {
     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;
@@ -5984,14 +6174,31 @@ void DriverGL::InitializeDebugBindings() {
     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;
@@ -6607,10 +6814,34 @@ void GLApiBase::glCopyTexSubImage3DFn(GLenum target,
                                     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);
 }
@@ -7541,6 +7772,19 @@ void GLApiBase::glShaderSourceFn(GLuint shader,
   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) {
@@ -7577,12 +7821,41 @@ void GLApiBase::glStencilOpSeparateFn(GLenum face,
   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,
@@ -7590,6 +7863,21 @@ void GLApiBase::glStencilThenCoverFillPathNVFn(GLuint path,
   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,
@@ -8400,11 +8688,39 @@ void TraceGLApi::glCopyTexSubImage3DFn(GLenum target,
                                  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);
@@ -9528,6 +9844,22 @@ void TraceGLApi::glShaderSourceFn(GLuint shader,
   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) {
@@ -9571,6 +9903,22 @@ void TraceGLApi::glStencilOpSeparateFn(GLenum face,
   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) {
@@ -9578,6 +9926,23 @@ void TraceGLApi::glStencilStrokePathNVFn(GLuint path,
   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,
@@ -9587,6 +9952,23 @@ void TraceGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
   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,
@@ -10504,12 +10886,40 @@ void NoContextGLApi::glCopyTexSubImage3DFn(GLenum target,
       << "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";
@@ -11843,6 +12253,21 @@ void NoContextGLApi::glShaderSourceFn(GLuint shader,
   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) {
@@ -11894,6 +12319,21 @@ void NoContextGLApi::glStencilOpSeparateFn(GLenum face,
       << "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) {
@@ -11903,6 +12343,22 @@ void NoContextGLApi::glStencilStrokePathNVFn(GLuint path,
       << "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,
@@ -11913,6 +12369,22 @@ void NoContextGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
                 "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,