// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
//
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// capture_gles_ext_autogen.h:
//   Capture functions for the OpenGL ES extension entry points.

#ifndef LIBANGLE_CAPTURE_GLES_ext_AUTOGEN_H_
#define LIBANGLE_CAPTURE_GLES_ext_AUTOGEN_H_

#include "common/PackedEnums.h"

namespace angle
{
struct ParamCapture;
}  // namespace angle

namespace gl
{
class Context;

// Method Captures

// GL_ANGLE_copy_texture_3d
void CaptureCopyTexture3DANGLE(Context *context,
                               GLuint sourceId,
                               GLint sourceLevel,
                               TextureTarget destTargetPacked,
                               GLuint destId,
                               GLint destLevel,
                               GLint internalFormat,
                               GLenum destType,
                               GLboolean unpackFlipY,
                               GLboolean unpackPremultiplyAlpha,
                               GLboolean unpackUnmultiplyAlpha);
void CaptureCopySubTexture3DANGLE(Context *context,
                                  GLuint sourceId,
                                  GLint sourceLevel,
                                  TextureTarget destTargetPacked,
                                  GLuint destId,
                                  GLint destLevel,
                                  GLint xoffset,
                                  GLint yoffset,
                                  GLint zoffset,
                                  GLint x,
                                  GLint y,
                                  GLint z,
                                  GLint width,
                                  GLint height,
                                  GLint depth,
                                  GLboolean unpackFlipY,
                                  GLboolean unpackPremultiplyAlpha,
                                  GLboolean unpackUnmultiplyAlpha);

// GL_ANGLE_framebuffer_blit
void CaptureBlitFramebufferANGLE(Context *context,
                                 GLint srcX0,
                                 GLint srcY0,
                                 GLint srcX1,
                                 GLint srcY1,
                                 GLint dstX0,
                                 GLint dstY0,
                                 GLint dstX1,
                                 GLint dstY1,
                                 GLbitfield mask,
                                 GLenum filter);

// GL_ANGLE_framebuffer_multisample
void CaptureRenderbufferStorageMultisampleANGLE(Context *context,
                                                GLenum target,
                                                GLsizei samples,
                                                GLenum internalformat,
                                                GLsizei width,
                                                GLsizei height);

// GL_ANGLE_instanced_arrays
void CaptureDrawArraysInstancedANGLE(Context *context,
                                     PrimitiveMode modePacked,
                                     GLint first,
                                     GLsizei count,
                                     GLsizei primcount);
void CaptureDrawElementsInstancedANGLE(Context *context,
                                       PrimitiveMode modePacked,
                                       GLsizei count,
                                       DrawElementsType typePacked,
                                       const void *indices,
                                       GLsizei primcount);
void CaptureVertexAttribDivisorANGLE(Context *context, GLuint index, GLuint divisor);

// GL_ANGLE_multi_draw
void CaptureMultiDrawArraysANGLE(Context *context,
                                 PrimitiveMode modePacked,
                                 const GLint *firsts,
                                 const GLsizei *counts,
                                 GLsizei drawcount);
void CaptureMultiDrawArraysInstancedANGLE(Context *context,
                                          PrimitiveMode modePacked,
                                          const GLint *firsts,
                                          const GLsizei *counts,
                                          const GLsizei *instanceCounts,
                                          GLsizei drawcount);
void CaptureMultiDrawElementsANGLE(Context *context,
                                   PrimitiveMode modePacked,
                                   const GLsizei *counts,
                                   DrawElementsType typePacked,
                                   const GLvoid *const *indices,
                                   GLsizei drawcount);
void CaptureMultiDrawElementsInstancedANGLE(Context *context,
                                            PrimitiveMode modePacked,
                                            const GLsizei *counts,
                                            DrawElementsType typePacked,
                                            const GLvoid *const *indices,
                                            const GLsizei *instanceCounts,
                                            GLsizei drawcount);

// GL_ANGLE_provoking_vertex
void CaptureProvokingVertexANGLE(Context *context, ProvokingVertex modePacked);

// GL_ANGLE_request_extension
void CaptureRequestExtensionANGLE(Context *context, const GLchar *name);

// GL_ANGLE_robust_client_memory
void CaptureGetBooleanvRobustANGLE(Context *context,
                                   GLenum pname,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLboolean *params);
void CaptureGetBufferParameterivRobustANGLE(Context *context,
                                            BufferBinding targetPacked,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params);
void CaptureGetFloatvRobustANGLE(Context *context,
                                 GLenum pname,
                                 GLsizei bufSize,
                                 GLsizei *length,
                                 GLfloat *params);
void CaptureGetFramebufferAttachmentParameterivRobustANGLE(Context *context,
                                                           GLenum target,
                                                           GLenum attachment,
                                                           GLenum pname,
                                                           GLsizei bufSize,
                                                           GLsizei *length,
                                                           GLint *params);
void CaptureGetIntegervRobustANGLE(Context *context,
                                   GLenum pname,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLint *data);
void CaptureGetProgramivRobustANGLE(Context *context,
                                    GLuint program,
                                    GLenum pname,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLint *params);
void CaptureGetRenderbufferParameterivRobustANGLE(Context *context,
                                                  GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLint *params);
void CaptureGetShaderivRobustANGLE(Context *context,
                                   GLuint shader,
                                   GLenum pname,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLint *params);
void CaptureGetTexParameterfvRobustANGLE(Context *context,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLfloat *params);
void CaptureGetTexParameterivRobustANGLE(Context *context,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLint *params);
void CaptureGetUniformfvRobustANGLE(Context *context,
                                    GLuint program,
                                    GLint location,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLfloat *params);
void CaptureGetUniformivRobustANGLE(Context *context,
                                    GLuint program,
                                    GLint location,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLint *params);
void CaptureGetVertexAttribfvRobustANGLE(Context *context,
                                         GLuint index,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLfloat *params);
void CaptureGetVertexAttribivRobustANGLE(Context *context,
                                         GLuint index,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLint *params);
void CaptureGetVertexAttribPointervRobustANGLE(Context *context,
                                               GLuint index,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               void **pointer);
void CaptureReadPixelsRobustANGLE(Context *context,
                                  GLint x,
                                  GLint y,
                                  GLsizei width,
                                  GLsizei height,
                                  GLenum format,
                                  GLenum type,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLsizei *columns,
                                  GLsizei *rows,
                                  void *pixels);
void CaptureTexImage2DRobustANGLE(Context *context,
                                  TextureTarget targetPacked,
                                  GLint level,
                                  GLint internalformat,
                                  GLsizei width,
                                  GLsizei height,
                                  GLint border,
                                  GLenum format,
                                  GLenum type,
                                  GLsizei bufSize,
                                  const void *pixels);
void CaptureTexParameterfvRobustANGLE(Context *context,
                                      TextureType targetPacked,
                                      GLenum pname,
                                      GLsizei bufSize,
                                      const GLfloat *params);
void CaptureTexParameterivRobustANGLE(Context *context,
                                      TextureType targetPacked,
                                      GLenum pname,
                                      GLsizei bufSize,
                                      const GLint *params);
void CaptureTexSubImage2DRobustANGLE(Context *context,
                                     TextureTarget targetPacked,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLenum format,
                                     GLenum type,
                                     GLsizei bufSize,
                                     const void *pixels);
void CaptureTexImage3DRobustANGLE(Context *context,
                                  TextureTarget targetPacked,
                                  GLint level,
                                  GLint internalformat,
                                  GLsizei width,
                                  GLsizei height,
                                  GLsizei depth,
                                  GLint border,
                                  GLenum format,
                                  GLenum type,
                                  GLsizei bufSize,
                                  const void *pixels);
void CaptureTexSubImage3DRobustANGLE(Context *context,
                                     TextureTarget targetPacked,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint zoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLenum format,
                                     GLenum type,
                                     GLsizei bufSize,
                                     const void *pixels);
void CaptureCompressedTexImage2DRobustANGLE(Context *context,
                                            TextureTarget targetPacked,
                                            GLint level,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height,
                                            GLint border,
                                            GLsizei imageSize,
                                            GLsizei dataSize,
                                            const GLvoid *data);
void CaptureCompressedTexSubImage2DRobustANGLE(Context *context,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLsizei xoffset,
                                               GLsizei yoffset,
                                               GLsizei width,
                                               GLsizei height,
                                               GLenum format,
                                               GLsizei imageSize,
                                               GLsizei dataSize,
                                               const GLvoid *data);
void CaptureCompressedTexImage3DRobustANGLE(Context *context,
                                            TextureTarget targetPacked,
                                            GLint level,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth,
                                            GLint border,
                                            GLsizei imageSize,
                                            GLsizei dataSize,
                                            const GLvoid *data);
void CaptureCompressedTexSubImage3DRobustANGLE(Context *context,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLint zoffset,
                                               GLsizei width,
                                               GLsizei height,
                                               GLsizei depth,
                                               GLenum format,
                                               GLsizei imageSize,
                                               GLsizei dataSize,
                                               const GLvoid *data);
void CaptureGetQueryivRobustANGLE(Context *context,
                                  QueryType targetPacked,
                                  GLenum pname,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLint *params);
void CaptureGetQueryObjectuivRobustANGLE(Context *context,
                                         GLuint id,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLuint *params);
void CaptureGetBufferPointervRobustANGLE(Context *context,
                                         BufferBinding targetPacked,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         void **params);
void CaptureGetIntegeri_vRobustANGLE(Context *context,
                                     GLenum target,
                                     GLuint index,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLint *data);
void CaptureGetInternalformativRobustANGLE(Context *context,
                                           GLenum target,
                                           GLenum internalformat,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params);
void CaptureGetVertexAttribIivRobustANGLE(Context *context,
                                          GLuint index,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *params);
void CaptureGetVertexAttribIuivRobustANGLE(Context *context,
                                           GLuint index,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLuint *params);
void CaptureGetUniformuivRobustANGLE(Context *context,
                                     GLuint program,
                                     GLint location,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLuint *params);
void CaptureGetActiveUniformBlockivRobustANGLE(Context *context,
                                               GLuint program,
                                               GLuint uniformBlockIndex,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLint *params);
void CaptureGetInteger64vRobustANGLE(Context *context,
                                     GLenum pname,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLint64 *data);
void CaptureGetInteger64i_vRobustANGLE(Context *context,
                                       GLenum target,
                                       GLuint index,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLint64 *data);
void CaptureGetBufferParameteri64vRobustANGLE(Context *context,
                                              BufferBinding targetPacked,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLint64 *params);
void CaptureSamplerParameterivRobustANGLE(Context *context,
                                          GLuint sampler,
                                          GLuint pname,
                                          GLsizei bufSize,
                                          const GLint *param);
void CaptureSamplerParameterfvRobustANGLE(Context *context,
                                          GLuint sampler,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          const GLfloat *param);
void CaptureGetSamplerParameterivRobustANGLE(Context *context,
                                             GLuint sampler,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLint *params);
void CaptureGetSamplerParameterfvRobustANGLE(Context *context,
                                             GLuint sampler,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLfloat *params);
void CaptureGetFramebufferParameterivRobustANGLE(Context *context,
                                                 GLuint sampler,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params);
void CaptureGetProgramInterfaceivRobustANGLE(Context *context,
                                             GLuint program,
                                             GLenum programInterface,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLint *params);
void CaptureGetBooleani_vRobustANGLE(Context *context,
                                     GLenum target,
                                     GLuint index,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLboolean *data);
void CaptureGetMultisamplefvRobustANGLE(Context *context,
                                        GLenum pname,
                                        GLuint index,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLfloat *val);
void CaptureGetTexLevelParameterivRobustANGLE(Context *context,
                                              TextureTarget targetPacked,
                                              GLint level,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLint *params);
void CaptureGetTexLevelParameterfvRobustANGLE(Context *context,
                                              TextureTarget targetPacked,
                                              GLint level,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLfloat *params);
void CaptureGetPointervRobustANGLERobustANGLE(Context *context,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              void **params);
void CaptureReadnPixelsRobustANGLE(Context *context,
                                   GLint x,
                                   GLint y,
                                   GLsizei width,
                                   GLsizei height,
                                   GLenum format,
                                   GLenum type,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLsizei *columns,
                                   GLsizei *rows,
                                   void *data);
void CaptureGetnUniformfvRobustANGLE(Context *context,
                                     GLuint program,
                                     GLint location,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLfloat *params);
void CaptureGetnUniformivRobustANGLE(Context *context,
                                     GLuint program,
                                     GLint location,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLint *params);
void CaptureGetnUniformuivRobustANGLE(Context *context,
                                      GLuint program,
                                      GLint location,
                                      GLsizei bufSize,
                                      GLsizei *length,
                                      GLuint *params);
void CaptureTexParameterIivRobustANGLE(Context *context,
                                       TextureType targetPacked,
                                       GLenum pname,
                                       GLsizei bufSize,
                                       const GLint *params);
void CaptureTexParameterIuivRobustANGLE(Context *context,
                                        TextureType targetPacked,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        const GLuint *params);
void CaptureGetTexParameterIivRobustANGLE(Context *context,
                                          TextureType targetPacked,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *params);
void CaptureGetTexParameterIuivRobustANGLE(Context *context,
                                           TextureType targetPacked,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLuint *params);
void CaptureSamplerParameterIivRobustANGLE(Context *context,
                                           GLuint sampler,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           const GLint *param);
void CaptureSamplerParameterIuivRobustANGLE(Context *context,
                                            GLuint sampler,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            const GLuint *param);
void CaptureGetSamplerParameterIivRobustANGLE(Context *context,
                                              GLuint sampler,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLint *params);
void CaptureGetSamplerParameterIuivRobustANGLE(Context *context,
                                               GLuint sampler,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLuint *params);
void CaptureGetQueryObjectivRobustANGLE(Context *context,
                                        GLuint id,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLint *params);
void CaptureGetQueryObjecti64vRobustANGLE(Context *context,
                                          GLuint id,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint64 *params);
void CaptureGetQueryObjectui64vRobustANGLE(Context *context,
                                           GLuint id,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLuint64 *params);

// GL_ANGLE_texture_external_update
void CaptureTexImage2DExternalANGLE(Context *context,
                                    TextureTarget targetPacked,
                                    GLint level,
                                    GLint internalformat,
                                    GLsizei width,
                                    GLsizei height,
                                    GLint border,
                                    GLenum format,
                                    GLenum type);
void CaptureInvalidateTextureANGLE(Context *context, TextureType targetPacked);

// GL_ANGLE_texture_multisample
void CaptureTexStorage2DMultisampleANGLE(Context *context,
                                         TextureType targetPacked,
                                         GLsizei samples,
                                         GLenum internalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLboolean fixedsamplelocations);
void CaptureGetTexLevelParameterivANGLE(Context *context,
                                        TextureTarget targetPacked,
                                        GLint level,
                                        GLenum pname,
                                        GLint *params);
void CaptureGetTexLevelParameterfvANGLE(Context *context,
                                        TextureTarget targetPacked,
                                        GLint level,
                                        GLenum pname,
                                        GLfloat *params);
void CaptureGetMultisamplefvANGLE(Context *context, GLenum pname, GLuint index, GLfloat *val);
void CaptureSampleMaskiANGLE(Context *context, GLuint maskNumber, GLbitfield mask);

// GL_ANGLE_translated_shader_source
void CaptureGetTranslatedShaderSourceANGLE(Context *context,
                                           GLuint shader,
                                           GLsizei bufsize,
                                           GLsizei *length,
                                           GLchar *source);

// GL_CHROMIUM_bind_uniform_location
void CaptureBindUniformLocationCHROMIUM(Context *context,
                                        GLuint program,
                                        GLint location,
                                        const GLchar *name);

// GL_CHROMIUM_copy_compressed_texture
void CaptureCompressedCopyTextureCHROMIUM(Context *context, GLuint sourceId, GLuint destId);

// GL_CHROMIUM_copy_texture
void CaptureCopyTextureCHROMIUM(Context *context,
                                GLuint sourceId,
                                GLint sourceLevel,
                                TextureTarget destTargetPacked,
                                GLuint destId,
                                GLint destLevel,
                                GLint internalFormat,
                                GLenum destType,
                                GLboolean unpackFlipY,
                                GLboolean unpackPremultiplyAlpha,
                                GLboolean unpackUnmultiplyAlpha);
void CaptureCopySubTextureCHROMIUM(Context *context,
                                   GLuint sourceId,
                                   GLint sourceLevel,
                                   TextureTarget destTargetPacked,
                                   GLuint destId,
                                   GLint destLevel,
                                   GLint xoffset,
                                   GLint yoffset,
                                   GLint x,
                                   GLint y,
                                   GLint width,
                                   GLint height,
                                   GLboolean unpackFlipY,
                                   GLboolean unpackPremultiplyAlpha,
                                   GLboolean unpackUnmultiplyAlpha);

// GL_CHROMIUM_framebuffer_mixed_samples
void CaptureCoverageModulationCHROMIUM(Context *context, GLenum components);
void CaptureMatrixLoadfCHROMIUM(Context *context, GLenum matrixMode, const GLfloat *matrix);
void CaptureMatrixLoadIdentityCHROMIUM(Context *context, GLenum matrixMode);

// GL_CHROMIUM_lose_context
void CaptureLoseContextCHROMIUM(Context *context,
                                GraphicsResetStatus currentPacked,
                                GraphicsResetStatus otherPacked);

// GL_CHROMIUM_path_rendering
void CaptureGenPathsCHROMIUM(Context *context, GLsizei range);
void CaptureDeletePathsCHROMIUM(Context *context, GLuint first, GLsizei range);
void CaptureIsPathCHROMIUM(Context *context, GLuint path);
void CapturePathCommandsCHROMIUM(Context *context,
                                 GLuint path,
                                 GLsizei numCommands,
                                 const GLubyte *commands,
                                 GLsizei numCoords,
                                 GLenum coordType,
                                 const void *coords);
void CapturePathParameterfCHROMIUM(Context *context, GLuint path, GLenum pname, GLfloat value);
void CapturePathParameteriCHROMIUM(Context *context, GLuint path, GLenum pname, GLint value);
void CaptureGetPathParameterfvCHROMIUM(Context *context, GLuint path, GLenum pname, GLfloat *value);
void CaptureGetPathParameterivCHROMIUM(Context *context, GLuint path, GLenum pname, GLint *value);
void CapturePathStencilFuncCHROMIUM(Context *context, GLenum func, GLint ref, GLuint mask);
void CaptureStencilFillPathCHROMIUM(Context *context, GLuint path, GLenum fillMode, GLuint mask);
void CaptureStencilStrokePathCHROMIUM(Context *context, GLuint path, GLint reference, GLuint mask);
void CaptureCoverFillPathCHROMIUM(Context *context, GLuint path, GLenum coverMode);
void CaptureCoverStrokePathCHROMIUM(Context *context, GLuint path, GLenum coverMode);
void CaptureStencilThenCoverFillPathCHROMIUM(Context *context,
                                             GLuint path,
                                             GLenum fillMode,
                                             GLuint mask,
                                             GLenum coverMode);
void CaptureStencilThenCoverStrokePathCHROMIUM(Context *context,
                                               GLuint path,
                                               GLint reference,
                                               GLuint mask,
                                               GLenum coverMode);
void CaptureCoverFillPathInstancedCHROMIUM(Context *context,
                                           GLsizei numPath,
                                           GLenum pathNameType,
                                           const void *paths,
                                           GLuint pathBase,
                                           GLenum coverMode,
                                           GLenum transformType,
                                           const GLfloat *transformValues);
void CaptureCoverStrokePathInstancedCHROMIUM(Context *context,
                                             GLsizei numPath,
                                             GLenum pathNameType,
                                             const void *paths,
                                             GLuint pathBase,
                                             GLenum coverMode,
                                             GLenum transformType,
                                             const GLfloat *transformValues);
void CaptureStencilStrokePathInstancedCHROMIUM(Context *context,
                                               GLsizei numPath,
                                               GLenum pathNameType,
                                               const void *paths,
                                               GLuint pathBase,
                                               GLint reference,
                                               GLuint mask,
                                               GLenum transformType,
                                               const GLfloat *transformValues);
void CaptureStencilFillPathInstancedCHROMIUM(Context *context,
                                             GLsizei numPaths,
                                             GLenum pathNameType,
                                             const void *paths,
                                             GLuint pathBase,
                                             GLenum fillMode,
                                             GLuint mask,
                                             GLenum transformType,
                                             const GLfloat *transformValues);
void CaptureStencilThenCoverFillPathInstancedCHROMIUM(Context *context,
                                                      GLsizei numPaths,
                                                      GLenum pathNameType,
                                                      const void *paths,
                                                      GLuint pathBase,
                                                      GLenum fillMode,
                                                      GLuint mask,
                                                      GLenum coverMode,
                                                      GLenum transformType,
                                                      const GLfloat *transformValues);
void CaptureStencilThenCoverStrokePathInstancedCHROMIUM(Context *context,
                                                        GLsizei numPaths,
                                                        GLenum pathNameType,
                                                        const void *paths,
                                                        GLuint pathBase,
                                                        GLint reference,
                                                        GLuint mask,
                                                        GLenum coverMode,
                                                        GLenum transformType,
                                                        const GLfloat *transformValues);
void CaptureBindFragmentInputLocationCHROMIUM(Context *context,
                                              GLuint programs,
                                              GLint location,
                                              const GLchar *name);
void CaptureProgramPathFragmentInputGenCHROMIUM(Context *context,
                                                GLuint program,
                                                GLint location,
                                                GLenum genMode,
                                                GLint components,
                                                const GLfloat *coeffs);

// GL_EXT_blend_func_extended
void CaptureBindFragDataLocationEXT(Context *context,
                                    GLuint program,
                                    GLuint color,
                                    const GLchar *name);
void CaptureBindFragDataLocationIndexedEXT(Context *context,
                                           GLuint program,
                                           GLuint colorNumber,
                                           GLuint index,
                                           const GLchar *name);
void CaptureGetFragDataIndexEXT(Context *context, GLuint program, const GLchar *name);
void CaptureGetProgramResourceLocationIndexEXT(Context *context,
                                               GLuint program,
                                               GLenum programInterface,
                                               const GLchar *name);

// GL_EXT_debug_marker
void CaptureInsertEventMarkerEXT(Context *context, GLsizei length, const GLchar *marker);
void CapturePopGroupMarkerEXT(Context *context);
void CapturePushGroupMarkerEXT(Context *context, GLsizei length, const GLchar *marker);

// GL_EXT_discard_framebuffer
void CaptureDiscardFramebufferEXT(Context *context,
                                  GLenum target,
                                  GLsizei numAttachments,
                                  const GLenum *attachments);

// GL_EXT_disjoint_timer_query
void CaptureBeginQueryEXT(Context *context, QueryType targetPacked, GLuint id);
void CaptureDeleteQueriesEXT(Context *context, GLsizei n, const GLuint *ids);
void CaptureEndQueryEXT(Context *context, QueryType targetPacked);
void CaptureGenQueriesEXT(Context *context, GLsizei n, GLuint *ids);
void CaptureGetQueryObjecti64vEXT(Context *context, GLuint id, GLenum pname, GLint64 *params);
void CaptureGetQueryObjectivEXT(Context *context, GLuint id, GLenum pname, GLint *params);
void CaptureGetQueryObjectui64vEXT(Context *context, GLuint id, GLenum pname, GLuint64 *params);
void CaptureGetQueryObjectuivEXT(Context *context, GLuint id, GLenum pname, GLuint *params);
void CaptureGetQueryivEXT(Context *context, QueryType targetPacked, GLenum pname, GLint *params);
void CaptureIsQueryEXT(Context *context, GLuint id);
void CaptureQueryCounterEXT(Context *context, GLuint id, QueryType targetPacked);

// GL_EXT_draw_buffers
void CaptureDrawBuffersEXT(Context *context, GLsizei n, const GLenum *bufs);

// GL_EXT_geometry_shader
void CaptureFramebufferTextureEXT(Context *context,
                                  GLenum target,
                                  GLenum attachment,
                                  GLuint texture,
                                  GLint level);

// GL_EXT_instanced_arrays
void CaptureDrawArraysInstancedEXT(Context *context,
                                   PrimitiveMode modePacked,
                                   GLint start,
                                   GLsizei count,
                                   GLsizei primcount);
void CaptureDrawElementsInstancedEXT(Context *context,
                                     PrimitiveMode modePacked,
                                     GLsizei count,
                                     DrawElementsType typePacked,
                                     const void *indices,
                                     GLsizei primcount);
void CaptureVertexAttribDivisorEXT(Context *context, GLuint index, GLuint divisor);

// GL_EXT_map_buffer_range
void CaptureFlushMappedBufferRangeEXT(Context *context,
                                      BufferBinding targetPacked,
                                      GLintptr offset,
                                      GLsizeiptr length);
void CaptureMapBufferRangeEXT(Context *context,
                              BufferBinding targetPacked,
                              GLintptr offset,
                              GLsizeiptr length,
                              GLbitfield access);

// GL_EXT_memory_object
void CaptureBufferStorageMemEXT(Context *context,
                                TextureType targetPacked,
                                GLsizeiptr size,
                                GLuint memory,
                                GLuint64 offset);
void CaptureCreateMemoryObjectsEXT(Context *context, GLsizei n, GLuint *memoryObjects);
void CaptureDeleteMemoryObjectsEXT(Context *context, GLsizei n, const GLuint *memoryObjects);
void CaptureGetMemoryObjectParameterivEXT(Context *context,
                                          GLuint memoryObject,
                                          GLenum pname,
                                          GLint *params);
void CaptureGetUnsignedBytevEXT(Context *context, GLenum pname, GLubyte *data);
void CaptureGetUnsignedBytei_vEXT(Context *context, GLenum target, GLuint index, GLubyte *data);
void CaptureIsMemoryObjectEXT(Context *context, GLuint memoryObject);
void CaptureMemoryObjectParameterivEXT(Context *context,
                                       GLuint memoryObject,
                                       GLenum pname,
                                       const GLint *params);
void CaptureTexStorageMem2DEXT(Context *context,
                               TextureType targetPacked,
                               GLsizei levels,
                               GLenum internalFormat,
                               GLsizei width,
                               GLsizei height,
                               GLuint memory,
                               GLuint64 offset);
void CaptureTexStorageMem2DMultisampleEXT(Context *context,
                                          TextureType targetPacked,
                                          GLsizei samples,
                                          GLenum internalFormat,
                                          GLsizei width,
                                          GLsizei height,
                                          GLboolean fixedSampleLocations,
                                          GLuint memory,
                                          GLuint64 offset);
void CaptureTexStorageMem3DEXT(Context *context,
                               TextureType targetPacked,
                               GLsizei levels,
                               GLenum internalFormat,
                               GLsizei width,
                               GLsizei height,
                               GLsizei depth,
                               GLuint memory,
                               GLuint64 offset);
void CaptureTexStorageMem3DMultisampleEXT(Context *context,
                                          TextureType targetPacked,
                                          GLsizei samples,
                                          GLenum internalFormat,
                                          GLsizei width,
                                          GLsizei height,
                                          GLsizei depth,
                                          GLboolean fixedSampleLocations,
                                          GLuint memory,
                                          GLuint64 offset);

// GL_EXT_memory_object_fd
void CaptureImportMemoryFdEXT(Context *context,
                              GLuint memory,
                              GLuint64 size,
                              HandleType handleTypePacked,
                              GLint fd);

// GL_EXT_occlusion_query_boolean

// GL_EXT_robustness
void CaptureGetGraphicsResetStatusEXT(Context *context);
void CaptureGetnUniformfvEXT(Context *context,
                             GLuint program,
                             GLint location,
                             GLsizei bufSize,
                             GLfloat *params);
void CaptureGetnUniformivEXT(Context *context,
                             GLuint program,
                             GLint location,
                             GLsizei bufSize,
                             GLint *params);
void CaptureReadnPixelsEXT(Context *context,
                           GLint x,
                           GLint y,
                           GLsizei width,
                           GLsizei height,
                           GLenum format,
                           GLenum type,
                           GLsizei bufSize,
                           void *data);

// GL_EXT_semaphore
void CaptureDeleteSemaphoresEXT(Context *context, GLsizei n, const GLuint *semaphores);
void CaptureGenSemaphoresEXT(Context *context, GLsizei n, GLuint *semaphores);
void CaptureGetSemaphoreParameterui64vEXT(Context *context,
                                          GLuint semaphore,
                                          GLenum pname,
                                          GLuint64 *params);
void CaptureIsSemaphoreEXT(Context *context, GLuint semaphore);
void CaptureSemaphoreParameterui64vEXT(Context *context,
                                       GLuint semaphore,
                                       GLenum pname,
                                       const GLuint64 *params);
void CaptureSignalSemaphoreEXT(Context *context,
                               GLuint semaphore,
                               GLuint numBufferBarriers,
                               const GLuint *buffers,
                               GLuint numTextureBarriers,
                               const GLuint *textures,
                               const GLenum *dstLayouts);
void CaptureWaitSemaphoreEXT(Context *context,
                             GLuint semaphore,
                             GLuint numBufferBarriers,
                             const GLuint *buffers,
                             GLuint numTextureBarriers,
                             const GLuint *textures,
                             const GLenum *srcLayouts);

// GL_EXT_semaphore_fd
void CaptureImportSemaphoreFdEXT(Context *context,
                                 GLuint semaphore,
                                 HandleType handleTypePacked,
                                 GLint fd);

// GL_EXT_texture_storage
void CaptureTexStorage1DEXT(Context *context,
                            GLenum target,
                            GLsizei levels,
                            GLenum internalformat,
                            GLsizei width);
void CaptureTexStorage2DEXT(Context *context,
                            TextureType targetPacked,
                            GLsizei levels,
                            GLenum internalformat,
                            GLsizei width,
                            GLsizei height);
void CaptureTexStorage3DEXT(Context *context,
                            TextureType targetPacked,
                            GLsizei levels,
                            GLenum internalformat,
                            GLsizei width,
                            GLsizei height,
                            GLsizei depth);

// GL_KHR_debug
void CaptureDebugMessageCallbackKHR(Context *context,
                                    GLDEBUGPROCKHR callback,
                                    const void *userParam);
void CaptureDebugMessageControlKHR(Context *context,
                                   GLenum source,
                                   GLenum type,
                                   GLenum severity,
                                   GLsizei count,
                                   const GLuint *ids,
                                   GLboolean enabled);
void CaptureDebugMessageInsertKHR(Context *context,
                                  GLenum source,
                                  GLenum type,
                                  GLuint id,
                                  GLenum severity,
                                  GLsizei length,
                                  const GLchar *buf);
void CaptureGetDebugMessageLogKHR(Context *context,
                                  GLuint count,
                                  GLsizei bufSize,
                                  GLenum *sources,
                                  GLenum *types,
                                  GLuint *ids,
                                  GLenum *severities,
                                  GLsizei *lengths,
                                  GLchar *messageLog);
void CaptureGetObjectLabelKHR(Context *context,
                              GLenum identifier,
                              GLuint name,
                              GLsizei bufSize,
                              GLsizei *length,
                              GLchar *label);
void CaptureGetObjectPtrLabelKHR(Context *context,
                                 const void *ptr,
                                 GLsizei bufSize,
                                 GLsizei *length,
                                 GLchar *label);
void CaptureGetPointervKHR(Context *context, GLenum pname, void **params);
void CaptureObjectLabelKHR(Context *context,
                           GLenum identifier,
                           GLuint name,
                           GLsizei length,
                           const GLchar *label);
void CaptureObjectPtrLabelKHR(Context *context,
                              const void *ptr,
                              GLsizei length,
                              const GLchar *label);
void CapturePopDebugGroupKHR(Context *context);
void CapturePushDebugGroupKHR(Context *context,
                              GLenum source,
                              GLuint id,
                              GLsizei length,
                              const GLchar *message);

// GL_KHR_parallel_shader_compile
void CaptureMaxShaderCompilerThreadsKHR(Context *context, GLuint count);

// GL_NV_fence
void CaptureDeleteFencesNV(Context *context, GLsizei n, const GLuint *fences);
void CaptureFinishFenceNV(Context *context, GLuint fence);
void CaptureGenFencesNV(Context *context, GLsizei n, GLuint *fences);
void CaptureGetFenceivNV(Context *context, GLuint fence, GLenum pname, GLint *params);
void CaptureIsFenceNV(Context *context, GLuint fence);
void CaptureSetFenceNV(Context *context, GLuint fence, GLenum condition);
void CaptureTestFenceNV(Context *context, GLuint fence);

// GL_OES_EGL_image
void CaptureEGLImageTargetRenderbufferStorageOES(Context *context,
                                                 GLenum target,
                                                 GLeglImageOES image);
void CaptureEGLImageTargetTexture2DOES(Context *context,
                                       TextureType targetPacked,
                                       GLeglImageOES image);

// GL_OES_draw_texture
void CaptureDrawTexfOES(Context *context,
                        GLfloat x,
                        GLfloat y,
                        GLfloat z,
                        GLfloat width,
                        GLfloat height);
void CaptureDrawTexfvOES(Context *context, const GLfloat *coords);
void CaptureDrawTexiOES(Context *context, GLint x, GLint y, GLint z, GLint width, GLint height);
void CaptureDrawTexivOES(Context *context, const GLint *coords);
void CaptureDrawTexsOES(Context *context,
                        GLshort x,
                        GLshort y,
                        GLshort z,
                        GLshort width,
                        GLshort height);
void CaptureDrawTexsvOES(Context *context, const GLshort *coords);
void CaptureDrawTexxOES(Context *context,
                        GLfixed x,
                        GLfixed y,
                        GLfixed z,
                        GLfixed width,
                        GLfixed height);
void CaptureDrawTexxvOES(Context *context, const GLfixed *coords);

// GL_OES_framebuffer_object
void CaptureBindFramebufferOES(Context *context, GLenum target, GLuint framebuffer);
void CaptureBindRenderbufferOES(Context *context, GLenum target, GLuint renderbuffer);
void CaptureCheckFramebufferStatusOES(Context *context, GLenum target);
void CaptureDeleteFramebuffersOES(Context *context, GLsizei n, const GLuint *framebuffers);
void CaptureDeleteRenderbuffersOES(Context *context, GLsizei n, const GLuint *renderbuffers);
void CaptureFramebufferRenderbufferOES(Context *context,
                                       GLenum target,
                                       GLenum attachment,
                                       GLenum renderbuffertarget,
                                       GLuint renderbuffer);
void CaptureFramebufferTexture2DOES(Context *context,
                                    GLenum target,
                                    GLenum attachment,
                                    TextureTarget textargetPacked,
                                    GLuint texture,
                                    GLint level);
void CaptureGenFramebuffersOES(Context *context, GLsizei n, GLuint *framebuffers);
void CaptureGenRenderbuffersOES(Context *context, GLsizei n, GLuint *renderbuffers);
void CaptureGenerateMipmapOES(Context *context, TextureType targetPacked);
void CaptureGetFramebufferAttachmentParameterivOES(Context *context,
                                                   GLenum target,
                                                   GLenum attachment,
                                                   GLenum pname,
                                                   GLint *params);
void CaptureGetRenderbufferParameterivOES(Context *context,
                                          GLenum target,
                                          GLenum pname,
                                          GLint *params);
void CaptureIsFramebufferOES(Context *context, GLuint framebuffer);
void CaptureIsRenderbufferOES(Context *context, GLuint renderbuffer);
void CaptureRenderbufferStorageOES(Context *context,
                                   GLenum target,
                                   GLenum internalformat,
                                   GLsizei width,
                                   GLsizei height);

// GL_OES_get_program_binary
void CaptureGetProgramBinaryOES(Context *context,
                                GLuint program,
                                GLsizei bufSize,
                                GLsizei *length,
                                GLenum *binaryFormat,
                                void *binary);
void CaptureProgramBinaryOES(Context *context,
                             GLuint program,
                             GLenum binaryFormat,
                             const void *binary,
                             GLint length);

// GL_OES_mapbuffer
void CaptureGetBufferPointervOES(Context *context,
                                 BufferBinding targetPacked,
                                 GLenum pname,
                                 void **params);
void CaptureMapBufferOES(Context *context, BufferBinding targetPacked, GLenum access);
void CaptureUnmapBufferOES(Context *context, BufferBinding targetPacked);

// GL_OES_matrix_palette
void CaptureCurrentPaletteMatrixOES(Context *context, GLuint matrixpaletteindex);
void CaptureLoadPaletteFromModelViewMatrixOES(Context *context);
void CaptureMatrixIndexPointerOES(Context *context,
                                  GLint size,
                                  GLenum type,
                                  GLsizei stride,
                                  const void *pointer);
void CaptureWeightPointerOES(Context *context,
                             GLint size,
                             GLenum type,
                             GLsizei stride,
                             const void *pointer);

// GL_OES_point_size_array
void CapturePointSizePointerOES(Context *context,
                                VertexAttribType typePacked,
                                GLsizei stride,
                                const void *pointer);

// GL_OES_query_matrix
void CaptureQueryMatrixxOES(Context *context, GLfixed *mantissa, GLint *exponent);

// GL_OES_texture_3D
void CaptureCompressedTexImage3DOES(Context *context,
                                    TextureTarget targetPacked,
                                    GLint level,
                                    GLenum internalformat,
                                    GLsizei width,
                                    GLsizei height,
                                    GLsizei depth,
                                    GLint border,
                                    GLsizei imageSize,
                                    const void *data);
void CaptureCompressedTexSubImage3DOES(Context *context,
                                       TextureTarget targetPacked,
                                       GLint level,
                                       GLint xoffset,
                                       GLint yoffset,
                                       GLint zoffset,
                                       GLsizei width,
                                       GLsizei height,
                                       GLsizei depth,
                                       GLenum format,
                                       GLsizei imageSize,
                                       const void *data);
void CaptureCopyTexSubImage3DOES(Context *context,
                                 TextureTarget targetPacked,
                                 GLint level,
                                 GLint xoffset,
                                 GLint yoffset,
                                 GLint zoffset,
                                 GLint x,
                                 GLint y,
                                 GLsizei width,
                                 GLsizei height);
void CaptureFramebufferTexture3DOES(Context *context,
                                    GLenum target,
                                    GLenum attachment,
                                    TextureTarget textargetPacked,
                                    GLuint texture,
                                    GLint level,
                                    GLint zoffset);
void CaptureTexImage3DOES(Context *context,
                          TextureTarget targetPacked,
                          GLint level,
                          GLenum internalformat,
                          GLsizei width,
                          GLsizei height,
                          GLsizei depth,
                          GLint border,
                          GLenum format,
                          GLenum type,
                          const void *pixels);
void CaptureTexSubImage3DOES(Context *context,
                             TextureTarget targetPacked,
                             GLint level,
                             GLint xoffset,
                             GLint yoffset,
                             GLint zoffset,
                             GLsizei width,
                             GLsizei height,
                             GLsizei depth,
                             GLenum format,
                             GLenum type,
                             const void *pixels);

// GL_OES_texture_border_clamp
void CaptureGetSamplerParameterIivOES(Context *context,
                                      GLuint sampler,
                                      GLenum pname,
                                      GLint *params);
void CaptureGetSamplerParameterIuivOES(Context *context,
                                       GLuint sampler,
                                       GLenum pname,
                                       GLuint *params);
void CaptureGetTexParameterIivOES(Context *context,
                                  TextureType targetPacked,
                                  GLenum pname,
                                  GLint *params);
void CaptureGetTexParameterIuivOES(Context *context,
                                   TextureType targetPacked,
                                   GLenum pname,
                                   GLuint *params);
void CaptureSamplerParameterIivOES(Context *context,
                                   GLuint sampler,
                                   GLenum pname,
                                   const GLint *param);
void CaptureSamplerParameterIuivOES(Context *context,
                                    GLuint sampler,
                                    GLenum pname,
                                    const GLuint *param);
void CaptureTexParameterIivOES(Context *context,
                               TextureType targetPacked,
                               GLenum pname,
                               const GLint *params);
void CaptureTexParameterIuivOES(Context *context,
                                TextureType targetPacked,
                                GLenum pname,
                                const GLuint *params);

// GL_OES_texture_cube_map
void CaptureGetTexGenfvOES(Context *context, GLenum coord, GLenum pname, GLfloat *params);
void CaptureGetTexGenivOES(Context *context, GLenum coord, GLenum pname, GLint *params);
void CaptureGetTexGenxvOES(Context *context, GLenum coord, GLenum pname, GLfixed *params);
void CaptureTexGenfOES(Context *context, GLenum coord, GLenum pname, GLfloat param);
void CaptureTexGenfvOES(Context *context, GLenum coord, GLenum pname, const GLfloat *params);
void CaptureTexGeniOES(Context *context, GLenum coord, GLenum pname, GLint param);
void CaptureTexGenivOES(Context *context, GLenum coord, GLenum pname, const GLint *params);
void CaptureTexGenxOES(Context *context, GLenum coord, GLenum pname, GLfixed param);
void CaptureTexGenxvOES(Context *context, GLenum coord, GLenum pname, const GLfixed *params);

// GL_OES_texture_storage_multisample_2d_array
void CaptureTexStorage3DMultisampleOES(Context *context,
                                       TextureType targetPacked,
                                       GLsizei samples,
                                       GLenum internalformat,
                                       GLsizei width,
                                       GLsizei height,
                                       GLsizei depth,
                                       GLboolean fixedsamplelocations);

// GL_OES_vertex_array_object
void CaptureBindVertexArrayOES(Context *context, GLuint array);
void CaptureDeleteVertexArraysOES(Context *context, GLsizei n, const GLuint *arrays);
void CaptureGenVertexArraysOES(Context *context, GLsizei n, GLuint *arrays);
void CaptureIsVertexArrayOES(Context *context, GLuint array);

// GL_OVR_multiview
void CaptureFramebufferTextureMultiviewOVR(Context *context,
                                           GLenum target,
                                           GLenum attachment,
                                           GLuint texture,
                                           GLint level,
                                           GLint baseViewIndex,
                                           GLsizei numViews);

// GL_OVR_multiview2

// Parameter Captures

void CaptureDrawElementsInstancedANGLE_indices(Context *context,
                                               PrimitiveMode modePacked,
                                               GLsizei count,
                                               DrawElementsType typePacked,
                                               const void *indices,
                                               GLsizei primcount,
                                               bool isCallValid,
                                               angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysANGLE_firsts(Context *context,
                                        PrimitiveMode modePacked,
                                        const GLint *firsts,
                                        const GLsizei *counts,
                                        GLsizei drawcount,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysANGLE_counts(Context *context,
                                        PrimitiveMode modePacked,
                                        const GLint *firsts,
                                        const GLsizei *counts,
                                        GLsizei drawcount,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_firsts(Context *context,
                                                 PrimitiveMode modePacked,
                                                 const GLint *firsts,
                                                 const GLsizei *counts,
                                                 const GLsizei *instanceCounts,
                                                 GLsizei drawcount,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_counts(Context *context,
                                                 PrimitiveMode modePacked,
                                                 const GLint *firsts,
                                                 const GLsizei *counts,
                                                 const GLsizei *instanceCounts,
                                                 GLsizei drawcount,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_instanceCounts(Context *context,
                                                         PrimitiveMode modePacked,
                                                         const GLint *firsts,
                                                         const GLsizei *counts,
                                                         const GLsizei *instanceCounts,
                                                         GLsizei drawcount,
                                                         bool isCallValid,
                                                         angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsANGLE_counts(Context *context,
                                          PrimitiveMode modePacked,
                                          const GLsizei *counts,
                                          DrawElementsType typePacked,
                                          const GLvoid *const *indices,
                                          GLsizei drawcount,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsANGLE_indices(Context *context,
                                           PrimitiveMode modePacked,
                                           const GLsizei *counts,
                                           DrawElementsType typePacked,
                                           const GLvoid *const *indices,
                                           GLsizei drawcount,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedANGLE_counts(Context *context,
                                                   PrimitiveMode modePacked,
                                                   const GLsizei *counts,
                                                   DrawElementsType typePacked,
                                                   const GLvoid *const *indices,
                                                   const GLsizei *instanceCounts,
                                                   GLsizei drawcount,
                                                   bool isCallValid,
                                                   angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedANGLE_indices(Context *context,
                                                    PrimitiveMode modePacked,
                                                    const GLsizei *counts,
                                                    DrawElementsType typePacked,
                                                    const GLvoid *const *indices,
                                                    const GLsizei *instanceCounts,
                                                    GLsizei drawcount,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedANGLE_instanceCounts(Context *context,
                                                           PrimitiveMode modePacked,
                                                           const GLsizei *counts,
                                                           DrawElementsType typePacked,
                                                           const GLvoid *const *indices,
                                                           const GLsizei *instanceCounts,
                                                           GLsizei drawcount,
                                                           bool isCallValid,
                                                           angle::ParamCapture *paramCapture);
void CaptureRequestExtensionANGLE_name(Context *context,
                                       const GLchar *name,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureGetBooleanvRobustANGLE_length(Context *context,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLboolean *params,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetBooleanvRobustANGLE_params(Context *context,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLboolean *params,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetBufferParameterivRobustANGLE_length(Context *context,
                                                   BufferBinding targetPacked,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint *params,
                                                   bool isCallValid,
                                                   angle::ParamCapture *paramCapture);
void CaptureGetBufferParameterivRobustANGLE_params(Context *context,
                                                   BufferBinding targetPacked,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint *params,
                                                   bool isCallValid,
                                                   angle::ParamCapture *paramCapture);
void CaptureGetFloatvRobustANGLE_length(Context *context,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLfloat *params,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetFloatvRobustANGLE_params(Context *context,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLfloat *params,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
    Context *context,
    GLenum target,
    GLenum attachment,
    GLenum pname,
    GLsizei bufSize,
    GLsizei *length,
    GLint *params,
    bool isCallValid,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
    Context *context,
    GLenum target,
    GLenum attachment,
    GLenum pname,
    GLsizei bufSize,
    GLsizei *length,
    GLint *params,
    bool isCallValid,
    angle::ParamCapture *paramCapture);
void CaptureGetIntegervRobustANGLE_length(Context *context,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *data,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetIntegervRobustANGLE_data(Context *context,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLint *data,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetProgramivRobustANGLE_length(Context *context,
                                           GLuint program,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureGetProgramivRobustANGLE_params(Context *context,
                                           GLuint program,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivRobustANGLE_length(Context *context,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLint *params,
                                                         bool isCallValid,
                                                         angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivRobustANGLE_params(Context *context,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLint *params,
                                                         bool isCallValid,
                                                         angle::ParamCapture *paramCapture);
void CaptureGetShaderivRobustANGLE_length(Context *context,
                                          GLuint shader,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *params,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetShaderivRobustANGLE_params(Context *context,
                                          GLuint shader,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *params,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetTexParameterfvRobustANGLE_length(Context *context,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterfvRobustANGLE_params(Context *context,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterivRobustANGLE_length(Context *context,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterivRobustANGLE_params(Context *context,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetUniformfvRobustANGLE_length(Context *context,
                                           GLuint program,
                                           GLint location,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLfloat *params,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformfvRobustANGLE_params(Context *context,
                                           GLuint program,
                                           GLint location,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLfloat *params,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformivRobustANGLE_length(Context *context,
                                           GLuint program,
                                           GLint location,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformivRobustANGLE_params(Context *context,
                                           GLuint program,
                                           GLint location,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribfvRobustANGLE_length(Context *context,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribfvRobustANGLE_params(Context *context,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribivRobustANGLE_length(Context *context,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribivRobustANGLE_params(Context *context,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribPointervRobustANGLE_length(Context *context,
                                                      GLuint index,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      void **pointer,
                                                      bool isCallValid,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribPointervRobustANGLE_pointer(Context *context,
                                                       GLuint index,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       void **pointer,
                                                       bool isCallValid,
                                                       angle::ParamCapture *paramCapture);
void CaptureReadPixelsRobustANGLE_length(Context *context,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLsizei *columns,
                                         GLsizei *rows,
                                         void *pixels,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureReadPixelsRobustANGLE_columns(Context *context,
                                          GLint x,
                                          GLint y,
                                          GLsizei width,
                                          GLsizei height,
                                          GLenum format,
                                          GLenum type,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLsizei *columns,
                                          GLsizei *rows,
                                          void *pixels,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureReadPixelsRobustANGLE_rows(Context *context,
                                       GLint x,
                                       GLint y,
                                       GLsizei width,
                                       GLsizei height,
                                       GLenum format,
                                       GLenum type,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLsizei *columns,
                                       GLsizei *rows,
                                       void *pixels,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureReadPixelsRobustANGLE_pixels(Context *context,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLsizei *columns,
                                         GLsizei *rows,
                                         void *pixels,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureTexImage2DRobustANGLE_pixels(Context *context,
                                         TextureTarget targetPacked,
                                         GLint level,
                                         GLint internalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLint border,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         const void *pixels,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureTexParameterfvRobustANGLE_params(Context *context,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             const GLfloat *params,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureTexParameterivRobustANGLE_params(Context *context,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             const GLint *params,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureTexSubImage2DRobustANGLE_pixels(Context *context,
                                            TextureTarget targetPacked,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLsizei width,
                                            GLsizei height,
                                            GLenum format,
                                            GLenum type,
                                            GLsizei bufSize,
                                            const void *pixels,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureTexImage3DRobustANGLE_pixels(Context *context,
                                         TextureTarget targetPacked,
                                         GLint level,
                                         GLint internalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth,
                                         GLint border,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         const void *pixels,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureTexSubImage3DRobustANGLE_pixels(Context *context,
                                            TextureTarget targetPacked,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLint zoffset,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth,
                                            GLenum format,
                                            GLenum type,
                                            GLsizei bufSize,
                                            const void *pixels,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureCompressedTexImage2DRobustANGLE_data(Context *context,
                                                 TextureTarget targetPacked,
                                                 GLint level,
                                                 GLenum internalformat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLint border,
                                                 GLsizei imageSize,
                                                 GLsizei dataSize,
                                                 const GLvoid *data,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureCompressedTexSubImage2DRobustANGLE_data(Context *context,
                                                    TextureTarget targetPacked,
                                                    GLint level,
                                                    GLsizei xoffset,
                                                    GLsizei yoffset,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLenum format,
                                                    GLsizei imageSize,
                                                    GLsizei dataSize,
                                                    const GLvoid *data,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureCompressedTexImage3DRobustANGLE_data(Context *context,
                                                 TextureTarget targetPacked,
                                                 GLint level,
                                                 GLenum internalformat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLsizei depth,
                                                 GLint border,
                                                 GLsizei imageSize,
                                                 GLsizei dataSize,
                                                 const GLvoid *data,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureCompressedTexSubImage3DRobustANGLE_data(Context *context,
                                                    TextureTarget targetPacked,
                                                    GLint level,
                                                    GLint xoffset,
                                                    GLint yoffset,
                                                    GLint zoffset,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLsizei depth,
                                                    GLenum format,
                                                    GLsizei imageSize,
                                                    GLsizei dataSize,
                                                    const GLvoid *data,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetQueryivRobustANGLE_length(Context *context,
                                         QueryType targetPacked,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLint *params,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryivRobustANGLE_params(Context *context,
                                         QueryType targetPacked,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLint *params,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivRobustANGLE_length(Context *context,
                                                GLuint id,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLuint *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivRobustANGLE_params(Context *context,
                                                GLuint id,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLuint *params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervRobustANGLE_length(Context *context,
                                                BufferBinding targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                void **params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervRobustANGLE_params(Context *context,
                                                BufferBinding targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                void **params,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetIntegeri_vRobustANGLE_length(Context *context,
                                            GLenum target,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *data,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetIntegeri_vRobustANGLE_data(Context *context,
                                          GLenum target,
                                          GLuint index,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *data,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetInternalformativRobustANGLE_length(Context *context,
                                                  GLenum target,
                                                  GLenum internalformat,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLint *params,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetInternalformativRobustANGLE_params(Context *context,
                                                  GLenum target,
                                                  GLenum internalformat,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLint *params,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIivRobustANGLE_length(Context *context,
                                                 GLuint index,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIivRobustANGLE_params(Context *context,
                                                 GLuint index,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIuivRobustANGLE_length(Context *context,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIuivRobustANGLE_params(Context *context,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetUniformuivRobustANGLE_length(Context *context,
                                            GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLuint *params,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetUniformuivRobustANGLE_params(Context *context,
                                            GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLuint *params,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockivRobustANGLE_length(Context *context,
                                                      GLuint program,
                                                      GLuint uniformBlockIndex,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLint *params,
                                                      bool isCallValid,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockivRobustANGLE_params(Context *context,
                                                      GLuint program,
                                                      GLuint uniformBlockIndex,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLint *params,
                                                      bool isCallValid,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetInteger64vRobustANGLE_length(Context *context,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint64 *data,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetInteger64vRobustANGLE_data(Context *context,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint64 *data,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetInteger64i_vRobustANGLE_length(Context *context,
                                              GLenum target,
                                              GLuint index,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLint64 *data,
                                              bool isCallValid,
                                              angle::ParamCapture *paramCapture);
void CaptureGetInteger64i_vRobustANGLE_data(Context *context,
                                            GLenum target,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint64 *data,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetBufferParameteri64vRobustANGLE_length(Context *context,
                                                     BufferBinding targetPacked,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint64 *params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetBufferParameteri64vRobustANGLE_params(Context *context,
                                                     BufferBinding targetPacked,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint64 *params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureSamplerParameterivRobustANGLE_param(Context *context,
                                                GLuint sampler,
                                                GLuint pname,
                                                GLsizei bufSize,
                                                const GLint *param,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureSamplerParameterfvRobustANGLE_param(Context *context,
                                                GLuint sampler,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                const GLfloat *param,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterivRobustANGLE_length(Context *context,
                                                    GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterivRobustANGLE_params(Context *context,
                                                    GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterfvRobustANGLE_length(Context *context,
                                                    GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLfloat *params,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterfvRobustANGLE_params(Context *context,
                                                    GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLfloat *params,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferParameterivRobustANGLE_length(Context *context,
                                                        GLuint sampler,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *params,
                                                        bool isCallValid,
                                                        angle::ParamCapture *paramCapture);
void CaptureGetFramebufferParameterivRobustANGLE_params(Context *context,
                                                        GLuint sampler,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *params,
                                                        bool isCallValid,
                                                        angle::ParamCapture *paramCapture);
void CaptureGetProgramInterfaceivRobustANGLE_length(Context *context,
                                                    GLuint program,
                                                    GLenum programInterface,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetProgramInterfaceivRobustANGLE_params(Context *context,
                                                    GLuint program,
                                                    GLenum programInterface,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetBooleani_vRobustANGLE_length(Context *context,
                                            GLenum target,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLboolean *data,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetBooleani_vRobustANGLE_data(Context *context,
                                          GLenum target,
                                          GLuint index,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLboolean *data,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvRobustANGLE_length(Context *context,
                                               GLenum pname,
                                               GLuint index,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLfloat *val,
                                               bool isCallValid,
                                               angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvRobustANGLE_val(Context *context,
                                            GLenum pname,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *val,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivRobustANGLE_length(Context *context,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivRobustANGLE_params(Context *context,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvRobustANGLE_length(Context *context,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLfloat *params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvRobustANGLE_params(Context *context,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLfloat *params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetPointervRobustANGLERobustANGLE_length(Context *context,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     void **params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetPointervRobustANGLERobustANGLE_params(Context *context,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     void **params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureReadnPixelsRobustANGLE_length(Context *context,
                                          GLint x,
                                          GLint y,
                                          GLsizei width,
                                          GLsizei height,
                                          GLenum format,
                                          GLenum type,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLsizei *columns,
                                          GLsizei *rows,
                                          void *data,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureReadnPixelsRobustANGLE_columns(Context *context,
                                           GLint x,
                                           GLint y,
                                           GLsizei width,
                                           GLsizei height,
                                           GLenum format,
                                           GLenum type,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLsizei *columns,
                                           GLsizei *rows,
                                           void *data,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureReadnPixelsRobustANGLE_rows(Context *context,
                                        GLint x,
                                        GLint y,
                                        GLsizei width,
                                        GLsizei height,
                                        GLenum format,
                                        GLenum type,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLsizei *columns,
                                        GLsizei *rows,
                                        void *data,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureReadnPixelsRobustANGLE_data(Context *context,
                                        GLint x,
                                        GLint y,
                                        GLsizei width,
                                        GLsizei height,
                                        GLenum format,
                                        GLenum type,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLsizei *columns,
                                        GLsizei *rows,
                                        void *data,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetnUniformfvRobustANGLE_length(Context *context,
                                            GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetnUniformfvRobustANGLE_params(Context *context,
                                            GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetnUniformivRobustANGLE_length(Context *context,
                                            GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetnUniformivRobustANGLE_params(Context *context,
                                            GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGetnUniformuivRobustANGLE_length(Context *context,
                                             GLuint program,
                                             GLint location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureGetnUniformuivRobustANGLE_params(Context *context,
                                             GLuint program,
                                             GLint location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureTexParameterIivRobustANGLE_params(Context *context,
                                              TextureType targetPacked,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              const GLint *params,
                                              bool isCallValid,
                                              angle::ParamCapture *paramCapture);
void CaptureTexParameterIuivRobustANGLE_params(Context *context,
                                               TextureType targetPacked,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               const GLuint *params,
                                               bool isCallValid,
                                               angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIivRobustANGLE_length(Context *context,
                                                 TextureType targetPacked,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIivRobustANGLE_params(Context *context,
                                                 TextureType targetPacked,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIuivRobustANGLE_length(Context *context,
                                                  TextureType targetPacked,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIuivRobustANGLE_params(Context *context,
                                                  TextureType targetPacked,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIivRobustANGLE_param(Context *context,
                                                 GLuint sampler,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 const GLint *param,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIuivRobustANGLE_param(Context *context,
                                                  GLuint sampler,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  const GLuint *param,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIivRobustANGLE_length(Context *context,
                                                     GLuint sampler,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIivRobustANGLE_params(Context *context,
                                                     GLuint sampler,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIuivRobustANGLE_length(Context *context,
                                                      GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLuint *params,
                                                      bool isCallValid,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIuivRobustANGLE_params(Context *context,
                                                      GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLuint *params,
                                                      bool isCallValid,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivRobustANGLE_length(Context *context,
                                               GLuint id,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLint *params,
                                               bool isCallValid,
                                               angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivRobustANGLE_params(Context *context,
                                               GLuint id,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLint *params,
                                               bool isCallValid,
                                               angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vRobustANGLE_length(Context *context,
                                                 GLuint id,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint64 *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vRobustANGLE_params(Context *context,
                                                 GLuint id,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint64 *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vRobustANGLE_length(Context *context,
                                                  GLuint id,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint64 *params,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vRobustANGLE_params(Context *context,
                                                  GLuint id,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint64 *params,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivANGLE_params(Context *context,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLenum pname,
                                               GLint *params,
                                               bool isCallValid,
                                               angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvANGLE_params(Context *context,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLenum pname,
                                               GLfloat *params,
                                               bool isCallValid,
                                               angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvANGLE_val(Context *context,
                                      GLenum pname,
                                      GLuint index,
                                      GLfloat *val,
                                      bool isCallValid,
                                      angle::ParamCapture *paramCapture);
void CaptureGetTranslatedShaderSourceANGLE_length(Context *context,
                                                  GLuint shader,
                                                  GLsizei bufsize,
                                                  GLsizei *length,
                                                  GLchar *source,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetTranslatedShaderSourceANGLE_source(Context *context,
                                                  GLuint shader,
                                                  GLsizei bufsize,
                                                  GLsizei *length,
                                                  GLchar *source,
                                                  bool isCallValid,
                                                  angle::ParamCapture *paramCapture);
void CaptureBindUniformLocationCHROMIUM_name(Context *context,
                                             GLuint program,
                                             GLint location,
                                             const GLchar *name,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureMatrixLoadfCHROMIUM_matrix(Context *context,
                                       GLenum matrixMode,
                                       const GLfloat *matrix,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CapturePathCommandsCHROMIUM_commands(Context *context,
                                          GLuint path,
                                          GLsizei numCommands,
                                          const GLubyte *commands,
                                          GLsizei numCoords,
                                          GLenum coordType,
                                          const void *coords,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CapturePathCommandsCHROMIUM_coords(Context *context,
                                        GLuint path,
                                        GLsizei numCommands,
                                        const GLubyte *commands,
                                        GLsizei numCoords,
                                        GLenum coordType,
                                        const void *coords,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetPathParameterfvCHROMIUM_value(Context *context,
                                             GLuint path,
                                             GLenum pname,
                                             GLfloat *value,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureGetPathParameterivCHROMIUM_value(Context *context,
                                             GLuint path,
                                             GLenum pname,
                                             GLint *value,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureCoverFillPathInstancedCHROMIUM_paths(Context *context,
                                                 GLsizei numPath,
                                                 GLenum pathNameType,
                                                 const void *paths,
                                                 GLuint pathBase,
                                                 GLenum coverMode,
                                                 GLenum transformType,
                                                 const GLfloat *transformValues,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureCoverFillPathInstancedCHROMIUM_transformValues(Context *context,
                                                           GLsizei numPath,
                                                           GLenum pathNameType,
                                                           const void *paths,
                                                           GLuint pathBase,
                                                           GLenum coverMode,
                                                           GLenum transformType,
                                                           const GLfloat *transformValues,
                                                           bool isCallValid,
                                                           angle::ParamCapture *paramCapture);
void CaptureCoverStrokePathInstancedCHROMIUM_paths(Context *context,
                                                   GLsizei numPath,
                                                   GLenum pathNameType,
                                                   const void *paths,
                                                   GLuint pathBase,
                                                   GLenum coverMode,
                                                   GLenum transformType,
                                                   const GLfloat *transformValues,
                                                   bool isCallValid,
                                                   angle::ParamCapture *paramCapture);
void CaptureCoverStrokePathInstancedCHROMIUM_transformValues(Context *context,
                                                             GLsizei numPath,
                                                             GLenum pathNameType,
                                                             const void *paths,
                                                             GLuint pathBase,
                                                             GLenum coverMode,
                                                             GLenum transformType,
                                                             const GLfloat *transformValues,
                                                             bool isCallValid,
                                                             angle::ParamCapture *paramCapture);
void CaptureStencilStrokePathInstancedCHROMIUM_paths(Context *context,
                                                     GLsizei numPath,
                                                     GLenum pathNameType,
                                                     const void *paths,
                                                     GLuint pathBase,
                                                     GLint reference,
                                                     GLuint mask,
                                                     GLenum transformType,
                                                     const GLfloat *transformValues,
                                                     bool isCallValid,
                                                     angle::ParamCapture *paramCapture);
void CaptureStencilStrokePathInstancedCHROMIUM_transformValues(Context *context,
                                                               GLsizei numPath,
                                                               GLenum pathNameType,
                                                               const void *paths,
                                                               GLuint pathBase,
                                                               GLint reference,
                                                               GLuint mask,
                                                               GLenum transformType,
                                                               const GLfloat *transformValues,
                                                               bool isCallValid,
                                                               angle::ParamCapture *paramCapture);
void CaptureStencilFillPathInstancedCHROMIUM_paths(Context *context,
                                                   GLsizei numPaths,
                                                   GLenum pathNameType,
                                                   const void *paths,
                                                   GLuint pathBase,
                                                   GLenum fillMode,
                                                   GLuint mask,
                                                   GLenum transformType,
                                                   const GLfloat *transformValues,
                                                   bool isCallValid,
                                                   angle::ParamCapture *paramCapture);
void CaptureStencilFillPathInstancedCHROMIUM_transformValues(Context *context,
                                                             GLsizei numPaths,
                                                             GLenum pathNameType,
                                                             const void *paths,
                                                             GLuint pathBase,
                                                             GLenum fillMode,
                                                             GLuint mask,
                                                             GLenum transformType,
                                                             const GLfloat *transformValues,
                                                             bool isCallValid,
                                                             angle::ParamCapture *paramCapture);
void CaptureStencilThenCoverFillPathInstancedCHROMIUM_paths(Context *context,
                                                            GLsizei numPaths,
                                                            GLenum pathNameType,
                                                            const void *paths,
                                                            GLuint pathBase,
                                                            GLenum fillMode,
                                                            GLuint mask,
                                                            GLenum coverMode,
                                                            GLenum transformType,
                                                            const GLfloat *transformValues,
                                                            bool isCallValid,
                                                            angle::ParamCapture *paramCapture);
void CaptureStencilThenCoverFillPathInstancedCHROMIUM_transformValues(
    Context *context,
    GLsizei numPaths,
    GLenum pathNameType,
    const void *paths,
    GLuint pathBase,
    GLenum fillMode,
    GLuint mask,
    GLenum coverMode,
    GLenum transformType,
    const GLfloat *transformValues,
    bool isCallValid,
    angle::ParamCapture *paramCapture);
void CaptureStencilThenCoverStrokePathInstancedCHROMIUM_paths(Context *context,
                                                              GLsizei numPaths,
                                                              GLenum pathNameType,
                                                              const void *paths,
                                                              GLuint pathBase,
                                                              GLint reference,
                                                              GLuint mask,
                                                              GLenum coverMode,
                                                              GLenum transformType,
                                                              const GLfloat *transformValues,
                                                              bool isCallValid,
                                                              angle::ParamCapture *paramCapture);
void CaptureStencilThenCoverStrokePathInstancedCHROMIUM_transformValues(
    Context *context,
    GLsizei numPaths,
    GLenum pathNameType,
    const void *paths,
    GLuint pathBase,
    GLint reference,
    GLuint mask,
    GLenum coverMode,
    GLenum transformType,
    const GLfloat *transformValues,
    bool isCallValid,
    angle::ParamCapture *paramCapture);
void CaptureBindFragmentInputLocationCHROMIUM_name(Context *context,
                                                   GLuint programs,
                                                   GLint location,
                                                   const GLchar *name,
                                                   bool isCallValid,
                                                   angle::ParamCapture *paramCapture);
void CaptureProgramPathFragmentInputGenCHROMIUM_coeffs(Context *context,
                                                       GLuint program,
                                                       GLint location,
                                                       GLenum genMode,
                                                       GLint components,
                                                       const GLfloat *coeffs,
                                                       bool isCallValid,
                                                       angle::ParamCapture *paramCapture);
void CaptureBindFragDataLocationEXT_name(Context *context,
                                         GLuint program,
                                         GLuint color,
                                         const GLchar *name,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureBindFragDataLocationIndexedEXT_name(Context *context,
                                                GLuint program,
                                                GLuint colorNumber,
                                                GLuint index,
                                                const GLchar *name,
                                                bool isCallValid,
                                                angle::ParamCapture *paramCapture);
void CaptureGetFragDataIndexEXT_name(Context *context,
                                     GLuint program,
                                     const GLchar *name,
                                     bool isCallValid,
                                     angle::ParamCapture *paramCapture);
void CaptureGetProgramResourceLocationIndexEXT_name(Context *context,
                                                    GLuint program,
                                                    GLenum programInterface,
                                                    const GLchar *name,
                                                    bool isCallValid,
                                                    angle::ParamCapture *paramCapture);
void CaptureInsertEventMarkerEXT_marker(Context *context,
                                        GLsizei length,
                                        const GLchar *marker,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CapturePushGroupMarkerEXT_marker(Context *context,
                                      GLsizei length,
                                      const GLchar *marker,
                                      bool isCallValid,
                                      angle::ParamCapture *paramCapture);
void CaptureDiscardFramebufferEXT_attachments(Context *context,
                                              GLenum target,
                                              GLsizei numAttachments,
                                              const GLenum *attachments,
                                              bool isCallValid,
                                              angle::ParamCapture *paramCapture);
void CaptureDeleteQueriesEXT_ids(Context *context,
                                 GLsizei n,
                                 const GLuint *ids,
                                 bool isCallValid,
                                 angle::ParamCapture *paramCapture);
void CaptureGenQueriesEXT_ids(Context *context,
                              GLsizei n,
                              GLuint *ids,
                              bool isCallValid,
                              angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vEXT_params(Context *context,
                                         GLuint id,
                                         GLenum pname,
                                         GLint64 *params,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivEXT_params(Context *context,
                                       GLuint id,
                                       GLenum pname,
                                       GLint *params,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vEXT_params(Context *context,
                                          GLuint id,
                                          GLenum pname,
                                          GLuint64 *params,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivEXT_params(Context *context,
                                        GLuint id,
                                        GLenum pname,
                                        GLuint *params,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetQueryivEXT_params(Context *context,
                                 QueryType targetPacked,
                                 GLenum pname,
                                 GLint *params,
                                 bool isCallValid,
                                 angle::ParamCapture *paramCapture);
void CaptureDrawBuffersEXT_bufs(Context *context,
                                GLsizei n,
                                const GLenum *bufs,
                                bool isCallValid,
                                angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedEXT_indices(Context *context,
                                             PrimitiveMode modePacked,
                                             GLsizei count,
                                             DrawElementsType typePacked,
                                             const void *indices,
                                             GLsizei primcount,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureCreateMemoryObjectsEXT_memoryObjects(Context *context,
                                                 GLsizei n,
                                                 GLuint *memoryObjects,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureDeleteMemoryObjectsEXT_memoryObjects(Context *context,
                                                 GLsizei n,
                                                 const GLuint *memoryObjects,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetMemoryObjectParameterivEXT_params(Context *context,
                                                 GLuint memoryObject,
                                                 GLenum pname,
                                                 GLint *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetUnsignedBytevEXT_data(Context *context,
                                     GLenum pname,
                                     GLubyte *data,
                                     bool isCallValid,
                                     angle::ParamCapture *paramCapture);
void CaptureGetUnsignedBytei_vEXT_data(Context *context,
                                       GLenum target,
                                       GLuint index,
                                       GLubyte *data,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureMemoryObjectParameterivEXT_params(Context *context,
                                              GLuint memoryObject,
                                              GLenum pname,
                                              const GLint *params,
                                              bool isCallValid,
                                              angle::ParamCapture *paramCapture);
void CaptureGetnUniformfvEXT_params(Context *context,
                                    GLuint program,
                                    GLint location,
                                    GLsizei bufSize,
                                    GLfloat *params,
                                    bool isCallValid,
                                    angle::ParamCapture *paramCapture);
void CaptureGetnUniformivEXT_params(Context *context,
                                    GLuint program,
                                    GLint location,
                                    GLsizei bufSize,
                                    GLint *params,
                                    bool isCallValid,
                                    angle::ParamCapture *paramCapture);
void CaptureReadnPixelsEXT_data(Context *context,
                                GLint x,
                                GLint y,
                                GLsizei width,
                                GLsizei height,
                                GLenum format,
                                GLenum type,
                                GLsizei bufSize,
                                void *data,
                                bool isCallValid,
                                angle::ParamCapture *paramCapture);
void CaptureDeleteSemaphoresEXT_semaphores(Context *context,
                                           GLsizei n,
                                           const GLuint *semaphores,
                                           bool isCallValid,
                                           angle::ParamCapture *paramCapture);
void CaptureGenSemaphoresEXT_semaphores(Context *context,
                                        GLsizei n,
                                        GLuint *semaphores,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetSemaphoreParameterui64vEXT_params(Context *context,
                                                 GLuint semaphore,
                                                 GLenum pname,
                                                 GLuint64 *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureSemaphoreParameterui64vEXT_params(Context *context,
                                              GLuint semaphore,
                                              GLenum pname,
                                              const GLuint64 *params,
                                              bool isCallValid,
                                              angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_buffers(Context *context,
                                       GLuint semaphore,
                                       GLuint numBufferBarriers,
                                       const GLuint *buffers,
                                       GLuint numTextureBarriers,
                                       const GLuint *textures,
                                       const GLenum *dstLayouts,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_textures(Context *context,
                                        GLuint semaphore,
                                        GLuint numBufferBarriers,
                                        const GLuint *buffers,
                                        GLuint numTextureBarriers,
                                        const GLuint *textures,
                                        const GLenum *dstLayouts,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_dstLayouts(Context *context,
                                          GLuint semaphore,
                                          GLuint numBufferBarriers,
                                          const GLuint *buffers,
                                          GLuint numTextureBarriers,
                                          const GLuint *textures,
                                          const GLenum *dstLayouts,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_buffers(Context *context,
                                     GLuint semaphore,
                                     GLuint numBufferBarriers,
                                     const GLuint *buffers,
                                     GLuint numTextureBarriers,
                                     const GLuint *textures,
                                     const GLenum *srcLayouts,
                                     bool isCallValid,
                                     angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_textures(Context *context,
                                      GLuint semaphore,
                                      GLuint numBufferBarriers,
                                      const GLuint *buffers,
                                      GLuint numTextureBarriers,
                                      const GLuint *textures,
                                      const GLenum *srcLayouts,
                                      bool isCallValid,
                                      angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_srcLayouts(Context *context,
                                        GLuint semaphore,
                                        GLuint numBufferBarriers,
                                        const GLuint *buffers,
                                        GLuint numTextureBarriers,
                                        const GLuint *textures,
                                        const GLenum *srcLayouts,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureDebugMessageCallbackKHR_userParam(Context *context,
                                              GLDEBUGPROCKHR callback,
                                              const void *userParam,
                                              bool isCallValid,
                                              angle::ParamCapture *paramCapture);
void CaptureDebugMessageControlKHR_ids(Context *context,
                                       GLenum source,
                                       GLenum type,
                                       GLenum severity,
                                       GLsizei count,
                                       const GLuint *ids,
                                       GLboolean enabled,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureDebugMessageInsertKHR_buf(Context *context,
                                      GLenum source,
                                      GLenum type,
                                      GLuint id,
                                      GLenum severity,
                                      GLsizei length,
                                      const GLchar *buf,
                                      bool isCallValid,
                                      angle::ParamCapture *paramCapture);
void CaptureGetDebugMessageLogKHR_sources(Context *context,
                                          GLuint count,
                                          GLsizei bufSize,
                                          GLenum *sources,
                                          GLenum *types,
                                          GLuint *ids,
                                          GLenum *severities,
                                          GLsizei *lengths,
                                          GLchar *messageLog,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetDebugMessageLogKHR_types(Context *context,
                                        GLuint count,
                                        GLsizei bufSize,
                                        GLenum *sources,
                                        GLenum *types,
                                        GLuint *ids,
                                        GLenum *severities,
                                        GLsizei *lengths,
                                        GLchar *messageLog,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetDebugMessageLogKHR_ids(Context *context,
                                      GLuint count,
                                      GLsizei bufSize,
                                      GLenum *sources,
                                      GLenum *types,
                                      GLuint *ids,
                                      GLenum *severities,
                                      GLsizei *lengths,
                                      GLchar *messageLog,
                                      bool isCallValid,
                                      angle::ParamCapture *paramCapture);
void CaptureGetDebugMessageLogKHR_severities(Context *context,
                                             GLuint count,
                                             GLsizei bufSize,
                                             GLenum *sources,
                                             GLenum *types,
                                             GLuint *ids,
                                             GLenum *severities,
                                             GLsizei *lengths,
                                             GLchar *messageLog,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureGetDebugMessageLogKHR_lengths(Context *context,
                                          GLuint count,
                                          GLsizei bufSize,
                                          GLenum *sources,
                                          GLenum *types,
                                          GLuint *ids,
                                          GLenum *severities,
                                          GLsizei *lengths,
                                          GLchar *messageLog,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureGetDebugMessageLogKHR_messageLog(Context *context,
                                             GLuint count,
                                             GLsizei bufSize,
                                             GLenum *sources,
                                             GLenum *types,
                                             GLuint *ids,
                                             GLenum *severities,
                                             GLsizei *lengths,
                                             GLchar *messageLog,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureGetObjectLabelKHR_length(Context *context,
                                     GLenum identifier,
                                     GLuint name,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *label,
                                     bool isCallValid,
                                     angle::ParamCapture *paramCapture);
void CaptureGetObjectLabelKHR_label(Context *context,
                                    GLenum identifier,
                                    GLuint name,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLchar *label,
                                    bool isCallValid,
                                    angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_ptr(Context *context,
                                     const void *ptr,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *label,
                                     bool isCallValid,
                                     angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_length(Context *context,
                                        const void *ptr,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLchar *label,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_label(Context *context,
                                       const void *ptr,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLchar *label,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureGetPointervKHR_params(Context *context,
                                  GLenum pname,
                                  void **params,
                                  bool isCallValid,
                                  angle::ParamCapture *paramCapture);
void CaptureObjectLabelKHR_label(Context *context,
                                 GLenum identifier,
                                 GLuint name,
                                 GLsizei length,
                                 const GLchar *label,
                                 bool isCallValid,
                                 angle::ParamCapture *paramCapture);
void CaptureObjectPtrLabelKHR_ptr(Context *context,
                                  const void *ptr,
                                  GLsizei length,
                                  const GLchar *label,
                                  bool isCallValid,
                                  angle::ParamCapture *paramCapture);
void CaptureObjectPtrLabelKHR_label(Context *context,
                                    const void *ptr,
                                    GLsizei length,
                                    const GLchar *label,
                                    bool isCallValid,
                                    angle::ParamCapture *paramCapture);
void CapturePushDebugGroupKHR_message(Context *context,
                                      GLenum source,
                                      GLuint id,
                                      GLsizei length,
                                      const GLchar *message,
                                      bool isCallValid,
                                      angle::ParamCapture *paramCapture);
void CaptureDeleteFencesNV_fences(Context *context,
                                  GLsizei n,
                                  const GLuint *fences,
                                  bool isCallValid,
                                  angle::ParamCapture *paramCapture);
void CaptureGenFencesNV_fences(Context *context,
                               GLsizei n,
                               GLuint *fences,
                               bool isCallValid,
                               angle::ParamCapture *paramCapture);
void CaptureGetFenceivNV_params(Context *context,
                                GLuint fence,
                                GLenum pname,
                                GLint *params,
                                bool isCallValid,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexfvOES_coords(Context *context,
                                const GLfloat *coords,
                                bool isCallValid,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexivOES_coords(Context *context,
                                const GLint *coords,
                                bool isCallValid,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexsvOES_coords(Context *context,
                                const GLshort *coords,
                                bool isCallValid,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexxvOES_coords(Context *context,
                                const GLfixed *coords,
                                bool isCallValid,
                                angle::ParamCapture *paramCapture);
void CaptureDeleteFramebuffersOES_framebuffers(Context *context,
                                               GLsizei n,
                                               const GLuint *framebuffers,
                                               bool isCallValid,
                                               angle::ParamCapture *paramCapture);
void CaptureDeleteRenderbuffersOES_renderbuffers(Context *context,
                                                 GLsizei n,
                                                 const GLuint *renderbuffers,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGenFramebuffersOES_framebuffers(Context *context,
                                            GLsizei n,
                                            GLuint *framebuffers,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureGenRenderbuffersOES_renderbuffers(Context *context,
                                              GLsizei n,
                                              GLuint *renderbuffers,
                                              bool isCallValid,
                                              angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivOES_params(Context *context,
                                                          GLenum target,
                                                          GLenum attachment,
                                                          GLenum pname,
                                                          GLint *params,
                                                          bool isCallValid,
                                                          angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivOES_params(Context *context,
                                                 GLenum target,
                                                 GLenum pname,
                                                 GLint *params,
                                                 bool isCallValid,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_length(Context *context,
                                       GLuint program,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLenum *binaryFormat,
                                       void *binary,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_binaryFormat(Context *context,
                                             GLuint program,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLenum *binaryFormat,
                                             void *binary,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_binary(Context *context,
                                       GLuint program,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLenum *binaryFormat,
                                       void *binary,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramBinaryOES_binary(Context *context,
                                    GLuint program,
                                    GLenum binaryFormat,
                                    const void *binary,
                                    GLint length,
                                    bool isCallValid,
                                    angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervOES_params(Context *context,
                                        BufferBinding targetPacked,
                                        GLenum pname,
                                        void **params,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureMatrixIndexPointerOES_pointer(Context *context,
                                          GLint size,
                                          GLenum type,
                                          GLsizei stride,
                                          const void *pointer,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureWeightPointerOES_pointer(Context *context,
                                     GLint size,
                                     GLenum type,
                                     GLsizei stride,
                                     const void *pointer,
                                     bool isCallValid,
                                     angle::ParamCapture *paramCapture);
void CapturePointSizePointerOES_pointer(Context *context,
                                        VertexAttribType typePacked,
                                        GLsizei stride,
                                        const void *pointer,
                                        bool isCallValid,
                                        angle::ParamCapture *paramCapture);
void CaptureQueryMatrixxOES_mantissa(Context *context,
                                     GLfixed *mantissa,
                                     GLint *exponent,
                                     bool isCallValid,
                                     angle::ParamCapture *paramCapture);
void CaptureQueryMatrixxOES_exponent(Context *context,
                                     GLfixed *mantissa,
                                     GLint *exponent,
                                     bool isCallValid,
                                     angle::ParamCapture *paramCapture);
void CaptureCompressedTexImage3DOES_data(Context *context,
                                         TextureTarget targetPacked,
                                         GLint level,
                                         GLenum internalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth,
                                         GLint border,
                                         GLsizei imageSize,
                                         const void *data,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureCompressedTexSubImage3DOES_data(Context *context,
                                            TextureTarget targetPacked,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLint zoffset,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth,
                                            GLenum format,
                                            GLsizei imageSize,
                                            const void *data,
                                            bool isCallValid,
                                            angle::ParamCapture *paramCapture);
void CaptureTexImage3DOES_pixels(Context *context,
                                 TextureTarget targetPacked,
                                 GLint level,
                                 GLenum internalformat,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLint border,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels,
                                 bool isCallValid,
                                 angle::ParamCapture *paramCapture);
void CaptureTexSubImage3DOES_pixels(Context *context,
                                    TextureTarget targetPacked,
                                    GLint level,
                                    GLint xoffset,
                                    GLint yoffset,
                                    GLint zoffset,
                                    GLsizei width,
                                    GLsizei height,
                                    GLsizei depth,
                                    GLenum format,
                                    GLenum type,
                                    const void *pixels,
                                    bool isCallValid,
                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIivOES_params(Context *context,
                                             GLuint sampler,
                                             GLenum pname,
                                             GLint *params,
                                             bool isCallValid,
                                             angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIuivOES_params(Context *context,
                                              GLuint sampler,
                                              GLenum pname,
                                              GLuint *params,
                                              bool isCallValid,
                                              angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIivOES_params(Context *context,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         GLint *params,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIuivOES_params(Context *context,
                                          TextureType targetPacked,
                                          GLenum pname,
                                          GLuint *params,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIivOES_param(Context *context,
                                         GLuint sampler,
                                         GLenum pname,
                                         const GLint *param,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIuivOES_param(Context *context,
                                          GLuint sampler,
                                          GLenum pname,
                                          const GLuint *param,
                                          bool isCallValid,
                                          angle::ParamCapture *paramCapture);
void CaptureTexParameterIivOES_params(Context *context,
                                      TextureType targetPacked,
                                      GLenum pname,
                                      const GLint *params,
                                      bool isCallValid,
                                      angle::ParamCapture *paramCapture);
void CaptureTexParameterIuivOES_params(Context *context,
                                       TextureType targetPacked,
                                       GLenum pname,
                                       const GLuint *params,
                                       bool isCallValid,
                                       angle::ParamCapture *paramCapture);
void CaptureGetTexGenfvOES_params(Context *context,
                                  GLenum coord,
                                  GLenum pname,
                                  GLfloat *params,
                                  bool isCallValid,
                                  angle::ParamCapture *paramCapture);
void CaptureGetTexGenivOES_params(Context *context,
                                  GLenum coord,
                                  GLenum pname,
                                  GLint *params,
                                  bool isCallValid,
                                  angle::ParamCapture *paramCapture);
void CaptureGetTexGenxvOES_params(Context *context,
                                  GLenum coord,
                                  GLenum pname,
                                  GLfixed *params,
                                  bool isCallValid,
                                  angle::ParamCapture *paramCapture);
void CaptureTexGenfvOES_params(Context *context,
                               GLenum coord,
                               GLenum pname,
                               const GLfloat *params,
                               bool isCallValid,
                               angle::ParamCapture *paramCapture);
void CaptureTexGenivOES_params(Context *context,
                               GLenum coord,
                               GLenum pname,
                               const GLint *params,
                               bool isCallValid,
                               angle::ParamCapture *paramCapture);
void CaptureTexGenxvOES_params(Context *context,
                               GLenum coord,
                               GLenum pname,
                               const GLfixed *params,
                               bool isCallValid,
                               angle::ParamCapture *paramCapture);
void CaptureDeleteVertexArraysOES_arrays(Context *context,
                                         GLsizei n,
                                         const GLuint *arrays,
                                         bool isCallValid,
                                         angle::ParamCapture *paramCapture);
void CaptureGenVertexArraysOES_arrays(Context *context,
                                      GLsizei n,
                                      GLuint *arrays,
                                      bool isCallValid,
                                      angle::ParamCapture *paramCapture);
}  // namespace gl

#endif  // LIBANGLE_CAPTURE_GLES_ext_AUTOGEN_H_
