command_buffer: Implement path rendering functions for CHROMIUM_path_rendering

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_glCoverFillPathNV(GLuint path, GLenum coverMode) {
+  MakeFunctionUnique("glCoverFillPathNV");
+  interface_->CoverFillPathNV(path, coverMode);
+}
+
+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();
 }
 
 GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateShader(GLenum type) {
   MakeFunctionUnique("glCreateShader");
   return interface_->CreateShader(type);
 }
 
@@ skipping 27 matching lines @@
   interface_->DeleteFramebuffersEXT(n, framebuffers);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glDeleteFramebuffersEXT(GLsizei n,
                                               const GLuint* framebuffers) {
   MakeFunctionUnique("glDeleteFramebuffersEXT");
   interface_->DeleteFramebuffersEXT(n, framebuffers);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glDeletePathsNV(GLuint path, GLsizei range) {
+  MakeFunctionUnique("glDeletePathsNV");
+  interface_->DeletePathsNV(path, range);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteProgram(GLuint program) {
   MakeFunctionUnique("glDeleteProgram");
   interface_->DeleteProgram(program);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glDeleteQueries(GLsizei n, const GLuint* ids) {
   MakeFunctionUnique("glDeleteQueries");
   interface_->DeleteQueries(n, ids);
 }
@@ skipping 408 matching lines @@
   MakeFunctionUnique("glGenFramebuffers");
   interface_->GenFramebuffersEXT(n, framebuffers);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) {
   MakeFunctionUnique("glGenFramebuffersEXT");
   interface_->GenFramebuffersEXT(n, framebuffers);
 }
 
+GLuint GL_BINDING_CALL MockGLInterface::Mock_glGenPathsNV(GLsizei range) {
+  MakeFunctionUnique("glGenPathsNV");
+  return interface_->GenPathsNV(range);
+}
+
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGenQueries(GLsizei n, GLuint* ids) {
   MakeFunctionUnique("glGenQueries");
   interface_->GenQueries(n, ids);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGenQueriesARB(GLsizei n, GLuint* ids) {
   MakeFunctionUnique("glGenQueriesARB");
   interface_->GenQueries(n, ids);
@@ skipping 657 matching lines @@
   MakeFunctionUnique("glIsFramebuffer");
   return interface_->IsFramebufferEXT(framebuffer);
 }
 
 GLboolean GL_BINDING_CALL
 MockGLInterface::Mock_glIsFramebufferEXT(GLuint framebuffer) {
   MakeFunctionUnique("glIsFramebufferEXT");
   return interface_->IsFramebufferEXT(framebuffer);
 }
 
+GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsPathNV(GLuint path) {
+  MakeFunctionUnique("glIsPathNV");
+  return interface_->IsPathNV(path);
+}
+
 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsProgram(GLuint program) {
   MakeFunctionUnique("glIsProgram");
   return interface_->IsProgram(program);
 }
 
 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQuery(GLuint query) {
   MakeFunctionUnique("glIsQuery");
   return interface_->IsQuery(query);
 }
 
@@ skipping 107 matching lines @@
   MakeFunctionUnique("glMatrixLoadIdentityEXT");
   interface_->MatrixLoadIdentityEXT(matrixMode);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glMatrixLoadfEXT(GLenum matrixMode, const GLfloat* m) {
   MakeFunctionUnique("glMatrixLoadfEXT");
   interface_->MatrixLoadfEXT(matrixMode, m);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glPathCommandsNV(GLuint path,
+                                       GLsizei numCommands,
+                                       const GLubyte* commands,
+                                       GLsizei numCoords,
+                                       GLenum coordType,
+                                       const GLvoid* coords) {
+  MakeFunctionUnique("glPathCommandsNV");
+  interface_->PathCommandsNV(path, numCommands, commands, numCoords, coordType,
+                             coords);
+}
+
+void GL_BINDING_CALL MockGLInterface::Mock_glPathParameterfNV(GLuint path,
+                                                              GLenum pname,
+                                                              GLfloat value) {
+  MakeFunctionUnique("glPathParameterfNV");
+  interface_->PathParameterfNV(path, pname, value);
+}
+
+void GL_BINDING_CALL MockGLInterface::Mock_glPathParameteriNV(GLuint path,
+                                                              GLenum pname,
+                                                              GLint value) {
+  MakeFunctionUnique("glPathParameteriNV");
+  interface_->PathParameteriNV(path, pname, value);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glPathStencilFuncNV(GLenum func, GLint ref, GLuint mask) {
+  MakeFunctionUnique("glPathStencilFuncNV");
+  interface_->PathStencilFuncNV(func, ref, mask);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glPauseTransformFeedback(void) {
   MakeFunctionUnique("glPauseTransformFeedback");
   interface_->PauseTransformFeedback();
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glPixelStorei(GLenum pname, GLint param) {
   MakeFunctionUnique("glPixelStorei");
   interface_->PixelStorei(pname, param);
 }
@@ skipping 212 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_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) {
   MakeFunctionUnique("glStencilFunc");
   interface_->StencilFunc(func, ref, mask);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glStencilFuncSeparate(GLenum face,
                                                                  GLenum func,
                                                                  GLint ref,
                                                                  GLuint mask) {
@@ skipping 19 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_glStencilStrokePathNV(GLuint path,
+                                            GLint reference,
+                                            GLuint mask) {
+  MakeFunctionUnique("glStencilStrokePathNV");
+  interface_->StencilStrokePathNV(path, reference, mask);
+}
+
+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_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");
   return interface_->TestFenceAPPLE(fence);
 }
 
 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glTestFenceNV(GLuint fence) {
   MakeFunctionUnique("glTestFenceNV");
   return interface_->TestFenceNV(fence);
 }
 
@@ skipping 652 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, "glCoverFillPathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glCoverFillPathNV);
+  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);
   if (strcmp(name, "glDeleteFencesAPPLE") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteFencesAPPLE);
   if (strcmp(name, "glDeleteFencesNV") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteFencesNV);
   if (strcmp(name, "glDeleteFramebuffers") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteFramebuffers);
   if (strcmp(name, "glDeleteFramebuffersEXT") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteFramebuffersEXT);
+  if (strcmp(name, "glDeletePathsNV") == 0)
+    return reinterpret_cast<void*>(Mock_glDeletePathsNV);
   if (strcmp(name, "glDeleteProgram") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteProgram);
   if (strcmp(name, "glDeleteQueries") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteQueries);
   if (strcmp(name, "glDeleteQueriesARB") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteQueriesARB);
   if (strcmp(name, "glDeleteQueriesEXT") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteQueriesEXT);
   if (strcmp(name, "glDeleteRenderbuffers") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteRenderbuffers);
@@ skipping 104 matching lines @@
   if (strcmp(name, "glGenBuffers") == 0)
     return reinterpret_cast<void*>(Mock_glGenBuffers);
   if (strcmp(name, "glGenFencesAPPLE") == 0)
     return reinterpret_cast<void*>(Mock_glGenFencesAPPLE);
   if (strcmp(name, "glGenFencesNV") == 0)
     return reinterpret_cast<void*>(Mock_glGenFencesNV);
   if (strcmp(name, "glGenFramebuffers") == 0)
     return reinterpret_cast<void*>(Mock_glGenFramebuffers);
   if (strcmp(name, "glGenFramebuffersEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGenFramebuffersEXT);
+  if (strcmp(name, "glGenPathsNV") == 0)
+    return reinterpret_cast<void*>(Mock_glGenPathsNV);
   if (strcmp(name, "glGenQueries") == 0)
     return reinterpret_cast<void*>(Mock_glGenQueries);
   if (strcmp(name, "glGenQueriesARB") == 0)
     return reinterpret_cast<void*>(Mock_glGenQueriesARB);
   if (strcmp(name, "glGenQueriesEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGenQueriesEXT);
   if (strcmp(name, "glGenRenderbuffers") == 0)
     return reinterpret_cast<void*>(Mock_glGenRenderbuffers);
   if (strcmp(name, "glGenRenderbuffersEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGenRenderbuffersEXT);
@@ skipping 163 matching lines @@
   if (strcmp(name, "glIsEnabled") == 0)
     return reinterpret_cast<void*>(Mock_glIsEnabled);
   if (strcmp(name, "glIsFenceAPPLE") == 0)
     return reinterpret_cast<void*>(Mock_glIsFenceAPPLE);
   if (strcmp(name, "glIsFenceNV") == 0)
     return reinterpret_cast<void*>(Mock_glIsFenceNV);
   if (strcmp(name, "glIsFramebuffer") == 0)
     return reinterpret_cast<void*>(Mock_glIsFramebuffer);
   if (strcmp(name, "glIsFramebufferEXT") == 0)
     return reinterpret_cast<void*>(Mock_glIsFramebufferEXT);
+  if (strcmp(name, "glIsPathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glIsPathNV);
   if (strcmp(name, "glIsProgram") == 0)
     return reinterpret_cast<void*>(Mock_glIsProgram);
   if (strcmp(name, "glIsQuery") == 0)
     return reinterpret_cast<void*>(Mock_glIsQuery);
   if (strcmp(name, "glIsQueryARB") == 0)
     return reinterpret_cast<void*>(Mock_glIsQueryARB);
   if (strcmp(name, "glIsQueryEXT") == 0)
     return reinterpret_cast<void*>(Mock_glIsQueryEXT);
   if (strcmp(name, "glIsRenderbuffer") == 0)
     return reinterpret_cast<void*>(Mock_glIsRenderbuffer);
@@ skipping 24 matching lines @@
   if (strcmp(name, "glMapBufferOES") == 0)
     return reinterpret_cast<void*>(Mock_glMapBufferOES);
   if (strcmp(name, "glMapBufferRange") == 0)
     return reinterpret_cast<void*>(Mock_glMapBufferRange);
   if (strcmp(name, "glMapBufferRangeEXT") == 0)
     return reinterpret_cast<void*>(Mock_glMapBufferRangeEXT);
   if (strcmp(name, "glMatrixLoadIdentityEXT") == 0)
     return reinterpret_cast<void*>(Mock_glMatrixLoadIdentityEXT);
   if (strcmp(name, "glMatrixLoadfEXT") == 0)
     return reinterpret_cast<void*>(Mock_glMatrixLoadfEXT);
+  if (strcmp(name, "glPathCommandsNV") == 0)
+    return reinterpret_cast<void*>(Mock_glPathCommandsNV);
+  if (strcmp(name, "glPathParameterfNV") == 0)
+    return reinterpret_cast<void*>(Mock_glPathParameterfNV);
+  if (strcmp(name, "glPathParameteriNV") == 0)
+    return reinterpret_cast<void*>(Mock_glPathParameteriNV);
+  if (strcmp(name, "glPathStencilFuncNV") == 0)
+    return reinterpret_cast<void*>(Mock_glPathStencilFuncNV);
   if (strcmp(name, "glPauseTransformFeedback") == 0)
     return reinterpret_cast<void*>(Mock_glPauseTransformFeedback);
   if (strcmp(name, "glPixelStorei") == 0)
     return reinterpret_cast<void*>(Mock_glPixelStorei);
   if (strcmp(name, "glPointParameteri") == 0)
     return reinterpret_cast<void*>(Mock_glPointParameteri);
   if (strcmp(name, "glPolygonOffset") == 0)
     return reinterpret_cast<void*>(Mock_glPolygonOffset);
   if (strcmp(name, "glPopGroupMarkerEXT") == 0)
     return reinterpret_cast<void*>(Mock_glPopGroupMarkerEXT);
@@ skipping 42 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, "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, "glStencilStrokePathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilStrokePathNV);
+  if (strcmp(name, "glStencilThenCoverFillPathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilThenCoverFillPathNV);
+  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);
   if (strcmp(name, "glTexParameterf") == 0)
     return reinterpret_cast<void*>(Mock_glTexParameterf);
@@ skipping 126 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