command_buffer: Support instanced path rendering in gpu command buffer

ui/gl/gl_bindings_autogen_mock.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 457 matching lines @@
                                                                GLint zoffset,
                                                                GLint x,
                                                                GLint y,
                                                                GLsizei width,
                                                                GLsizei height) {
   MakeFunctionUnique("glCopyTexSubImage3D");
   interface_->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y,
                                 width, height);
 }
 
+void GL_BINDING_CALL MockGLInterface::Mock_glCoverFillPathInstancedNV(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  MakeFunctionUnique("glCoverFillPathInstancedNV");
+  interface_->CoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase,
+                                       coverMode, transformType,
+                                       transformValues);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glCoverFillPathNV(GLuint path,
                                                              GLenum coverMode) {
   MakeFunctionUnique("glCoverFillPathNV");
   interface_->CoverFillPathNV(path, coverMode);
 }
 
+void GL_BINDING_CALL MockGLInterface::Mock_glCoverStrokePathInstancedNV(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  MakeFunctionUnique("glCoverStrokePathInstancedNV");
+  interface_->CoverStrokePathInstancedNV(numPaths, pathNameType, paths,
+                                         pathBase, coverMode, transformType,
+                                         transformValues);
+}
+
 void GL_BINDING_CALL
 MockGLInterface::Mock_glCoverStrokePathNV(GLuint name, GLenum coverMode) {
   MakeFunctionUnique("glCoverStrokePathNV");
   interface_->CoverStrokePathNV(name, coverMode);
 }
 
 GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateProgram(void) {
   MakeFunctionUnique("glCreateProgram");
   return interface_->CreateProgram();
 }
@@ skipping 1548 matching lines @@
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glShaderSource(GLuint shader,
                                      GLsizei count,
                                      const char* const* str,
                                      const GLint* length) {
   MakeFunctionUnique("glShaderSource");
   interface_->ShaderSource(shader, count, str, length);
 }
 
+void GL_BINDING_CALL MockGLInterface::Mock_glStencilFillPathInstancedNV(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  MakeFunctionUnique("glStencilFillPathInstancedNV");
+  interface_->StencilFillPathInstancedNV(numPaths, pathNameType, paths,
+                                         pathBase, fillMode, mask,
+                                         transformType, transformValues);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glStencilFillPathNV(GLuint path,
                                                                GLenum fillMode,
                                                                GLuint mask) {
   MakeFunctionUnique("glStencilFillPathNV");
   interface_->StencilFillPathNV(path, fillMode, mask);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glStencilFunc(GLenum func,
                                                          GLint ref,
                                                          GLuint mask) {
@@ skipping 28 matching lines @@
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glStencilOpSeparate(GLenum face,
                                                                GLenum fail,
                                                                GLenum zfail,
                                                                GLenum zpass) {
   MakeFunctionUnique("glStencilOpSeparate");
   interface_->StencilOpSeparate(face, fail, zfail, zpass);
 }
 
+void GL_BINDING_CALL MockGLInterface::Mock_glStencilStrokePathInstancedNV(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  MakeFunctionUnique("glStencilStrokePathInstancedNV");
+  interface_->StencilStrokePathInstancedNV(numPaths, pathNameType, paths,
+                                           pathBase, ref, mask, transformType,
+                                           transformValues);
+}
+
 void GL_BINDING_CALL
 MockGLInterface::Mock_glStencilStrokePathNV(GLuint path,
                                             GLint reference,
                                             GLuint mask) {
   MakeFunctionUnique("glStencilStrokePathNV");
   interface_->StencilStrokePathNV(path, reference, mask);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glStencilThenCoverFillPathInstancedNV(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  MakeFunctionUnique("glStencilThenCoverFillPathInstancedNV");
+  interface_->StencilThenCoverFillPathInstancedNV(
+      numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+      transformType, transformValues);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glStencilThenCoverFillPathNV(GLuint path,
                                                    GLenum fillMode,
                                                    GLuint mask,
                                                    GLenum coverMode) {
   MakeFunctionUnique("glStencilThenCoverFillPathNV");
   interface_->StencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glStencilThenCoverStrokePathInstancedNV(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  MakeFunctionUnique("glStencilThenCoverStrokePathInstancedNV");
+  interface_->StencilThenCoverStrokePathInstancedNV(
+      numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
+      transformType, transformValues);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glStencilThenCoverStrokePathNV(GLuint path,
                                                      GLint reference,
                                                      GLuint mask,
                                                      GLenum coverMode) {
   MakeFunctionUnique("glStencilThenCoverStrokePathNV");
   interface_->StencilThenCoverStrokePathNV(path, reference, mask, coverMode);
 }
 
 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glTestFenceAPPLE(GLuint fence) {
   MakeFunctionUnique("glTestFenceAPPLE");
@@ skipping 666 matching lines @@
   if (strcmp(name, "glCompressedTexSubImage3D") == 0)
     return reinterpret_cast<void*>(Mock_glCompressedTexSubImage3D);
   if (strcmp(name, "glCopyBufferSubData") == 0)
     return reinterpret_cast<void*>(Mock_glCopyBufferSubData);
   if (strcmp(name, "glCopyTexImage2D") == 0)
     return reinterpret_cast<void*>(Mock_glCopyTexImage2D);
   if (strcmp(name, "glCopyTexSubImage2D") == 0)
     return reinterpret_cast<void*>(Mock_glCopyTexSubImage2D);
   if (strcmp(name, "glCopyTexSubImage3D") == 0)
     return reinterpret_cast<void*>(Mock_glCopyTexSubImage3D);
+  if (strcmp(name, "glCoverFillPathInstancedNV") == 0)
+    return reinterpret_cast<void*>(Mock_glCoverFillPathInstancedNV);
   if (strcmp(name, "glCoverFillPathNV") == 0)
     return reinterpret_cast<void*>(Mock_glCoverFillPathNV);
+  if (strcmp(name, "glCoverStrokePathInstancedNV") == 0)
+    return reinterpret_cast<void*>(Mock_glCoverStrokePathInstancedNV);
   if (strcmp(name, "glCoverStrokePathNV") == 0)
     return reinterpret_cast<void*>(Mock_glCoverStrokePathNV);
   if (strcmp(name, "glCreateProgram") == 0)
     return reinterpret_cast<void*>(Mock_glCreateProgram);
   if (strcmp(name, "glCreateShader") == 0)
     return reinterpret_cast<void*>(Mock_glCreateShader);
   if (strcmp(name, "glCullFace") == 0)
     return reinterpret_cast<void*>(Mock_glCullFace);
   if (strcmp(name, "glDeleteBuffers") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteBuffers);
@@ skipping 425 matching lines @@
   if (strcmp(name, "glScissor") == 0)
     return reinterpret_cast<void*>(Mock_glScissor);
   if (strcmp(name, "glSetFenceAPPLE") == 0)
     return reinterpret_cast<void*>(Mock_glSetFenceAPPLE);
   if (strcmp(name, "glSetFenceNV") == 0)
     return reinterpret_cast<void*>(Mock_glSetFenceNV);
   if (strcmp(name, "glShaderBinary") == 0)
     return reinterpret_cast<void*>(Mock_glShaderBinary);
   if (strcmp(name, "glShaderSource") == 0)
     return reinterpret_cast<void*>(Mock_glShaderSource);
+  if (strcmp(name, "glStencilFillPathInstancedNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilFillPathInstancedNV);
   if (strcmp(name, "glStencilFillPathNV") == 0)
     return reinterpret_cast<void*>(Mock_glStencilFillPathNV);
   if (strcmp(name, "glStencilFunc") == 0)
     return reinterpret_cast<void*>(Mock_glStencilFunc);
   if (strcmp(name, "glStencilFuncSeparate") == 0)
     return reinterpret_cast<void*>(Mock_glStencilFuncSeparate);
   if (strcmp(name, "glStencilMask") == 0)
     return reinterpret_cast<void*>(Mock_glStencilMask);
   if (strcmp(name, "glStencilMaskSeparate") == 0)
     return reinterpret_cast<void*>(Mock_glStencilMaskSeparate);
   if (strcmp(name, "glStencilOp") == 0)
     return reinterpret_cast<void*>(Mock_glStencilOp);
   if (strcmp(name, "glStencilOpSeparate") == 0)
     return reinterpret_cast<void*>(Mock_glStencilOpSeparate);
+  if (strcmp(name, "glStencilStrokePathInstancedNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilStrokePathInstancedNV);
   if (strcmp(name, "glStencilStrokePathNV") == 0)
     return reinterpret_cast<void*>(Mock_glStencilStrokePathNV);
+  if (strcmp(name, "glStencilThenCoverFillPathInstancedNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilThenCoverFillPathInstancedNV);
   if (strcmp(name, "glStencilThenCoverFillPathNV") == 0)
     return reinterpret_cast<void*>(Mock_glStencilThenCoverFillPathNV);
+  if (strcmp(name, "glStencilThenCoverStrokePathInstancedNV") == 0)
+    return reinterpret_cast<void*>(
+        Mock_glStencilThenCoverStrokePathInstancedNV);
   if (strcmp(name, "glStencilThenCoverStrokePathNV") == 0)
     return reinterpret_cast<void*>(Mock_glStencilThenCoverStrokePathNV);
   if (strcmp(name, "glTestFenceAPPLE") == 0)
     return reinterpret_cast<void*>(Mock_glTestFenceAPPLE);
   if (strcmp(name, "glTestFenceNV") == 0)
     return reinterpret_cast<void*>(Mock_glTestFenceNV);
   if (strcmp(name, "glTexImage2D") == 0)
     return reinterpret_cast<void*>(Mock_glTexImage2D);
   if (strcmp(name, "glTexImage3D") == 0)
     return reinterpret_cast<void*>(Mock_glTexImage3D);
@@ skipping 128 matching lines @@
   if (strcmp(name, "glVertexAttribPointer") == 0)
     return reinterpret_cast<void*>(Mock_glVertexAttribPointer);
   if (strcmp(name, "glViewport") == 0)
     return reinterpret_cast<void*>(Mock_glViewport);
   if (strcmp(name, "glWaitSync") == 0)
     return reinterpret_cast<void*>(Mock_glWaitSync);
   return reinterpret_cast<void*>(&MockInvalidFunction);
 }
 
 }  // namespace gfx