// 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"
#include "libANGLE/FrameCapture.h"

namespace gl
{
class Context;

// Method Captures

// GL_ANGLE_base_vertex_base_instance
angle::CallCapture CaptureDrawArraysInstancedBaseInstanceANGLE(const Context *context,
                                                               bool isCallValid,
                                                               PrimitiveMode modePacked,
                                                               GLint first,
                                                               GLsizei count,
                                                               GLsizei instanceCount,
                                                               GLuint baseInstance);
angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE(
    const Context *context,
    bool isCallValid,
    PrimitiveMode modePacked,
    GLsizei count,
    DrawElementsType typePacked,
    const GLvoid *indices,
    GLsizei instanceCounts,
    GLint baseVertex,
    GLuint baseInstance);
angle::CallCapture CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const Context *context,
                                                                    bool isCallValid,
                                                                    PrimitiveMode modePacked,
                                                                    GLsizei drawcount,
                                                                    const GLsizei *counts,
                                                                    const GLsizei *instanceCounts,
                                                                    const GLint *firsts,
                                                                    const GLuint *baseInstances);
angle::CallCapture CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
    const Context *context,
    bool isCallValid,
    PrimitiveMode modePacked,
    DrawElementsType typePacked,
    GLsizei drawcount,
    const GLsizei *counts,
    const GLsizei *instanceCounts,
    const GLvoid *const *indices,
    const GLint *baseVertices,
    const GLuint *baseInstances);

// GL_ANGLE_copy_texture_3d
angle::CallCapture CaptureCopyTexture3DANGLE(const Context *context,
                                             bool isCallValid,
                                             TextureID sourceIdPacked,
                                             GLint sourceLevel,
                                             TextureTarget destTargetPacked,
                                             TextureID destIdPacked,
                                             GLint destLevel,
                                             GLint internalFormat,
                                             GLenum destType,
                                             GLboolean unpackFlipY,
                                             GLboolean unpackPremultiplyAlpha,
                                             GLboolean unpackUnmultiplyAlpha);
angle::CallCapture CaptureCopySubTexture3DANGLE(const Context *context,
                                                bool isCallValid,
                                                TextureID sourceIdPacked,
                                                GLint sourceLevel,
                                                TextureTarget destTargetPacked,
                                                TextureID destIdPacked,
                                                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
angle::CallCapture CaptureBlitFramebufferANGLE(const Context *context,
                                               bool isCallValid,
                                               GLint srcX0,
                                               GLint srcY0,
                                               GLint srcX1,
                                               GLint srcY1,
                                               GLint dstX0,
                                               GLint dstY0,
                                               GLint dstX1,
                                               GLint dstY1,
                                               GLbitfield mask,
                                               GLenum filter);

// GL_ANGLE_framebuffer_multisample
angle::CallCapture CaptureRenderbufferStorageMultisampleANGLE(const Context *context,
                                                              bool isCallValid,
                                                              GLenum target,
                                                              GLsizei samples,
                                                              GLenum internalformat,
                                                              GLsizei width,
                                                              GLsizei height);

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

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

// GL_ANGLE_provoking_vertex
angle::CallCapture CaptureProvokingVertexANGLE(const Context *context,
                                               bool isCallValid,
                                               ProvokingVertexConvention modePacked);

// GL_ANGLE_request_extension
angle::CallCapture CaptureRequestExtensionANGLE(const Context *context,
                                                bool isCallValid,
                                                const GLchar *name);

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

// GL_ANGLE_texture_external_update
angle::CallCapture CaptureTexImage2DExternalANGLE(const Context *context,
                                                  bool isCallValid,
                                                  TextureTarget targetPacked,
                                                  GLint level,
                                                  GLint internalformat,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLint border,
                                                  GLenum format,
                                                  GLenum type);
angle::CallCapture CaptureInvalidateTextureANGLE(const Context *context,
                                                 bool isCallValid,
                                                 TextureType targetPacked);

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

// GL_ANGLE_translated_shader_source
angle::CallCapture CaptureGetTranslatedShaderSourceANGLE(const Context *context,
                                                         bool isCallValid,
                                                         GLuint shader,
                                                         GLsizei bufsize,
                                                         GLsizei *length,
                                                         GLchar *source);

// GL_CHROMIUM_bind_uniform_location
angle::CallCapture CaptureBindUniformLocationCHROMIUM(const Context *context,
                                                      bool isCallValid,
                                                      GLuint program,
                                                      GLint location,
                                                      const GLchar *name);

// GL_CHROMIUM_copy_compressed_texture
angle::CallCapture CaptureCompressedCopyTextureCHROMIUM(const Context *context,
                                                        bool isCallValid,
                                                        TextureID sourceIdPacked,
                                                        TextureID destIdPacked);

// GL_CHROMIUM_copy_texture
angle::CallCapture CaptureCopyTextureCHROMIUM(const Context *context,
                                              bool isCallValid,
                                              TextureID sourceIdPacked,
                                              GLint sourceLevel,
                                              TextureTarget destTargetPacked,
                                              TextureID destIdPacked,
                                              GLint destLevel,
                                              GLint internalFormat,
                                              GLenum destType,
                                              GLboolean unpackFlipY,
                                              GLboolean unpackPremultiplyAlpha,
                                              GLboolean unpackUnmultiplyAlpha);
angle::CallCapture CaptureCopySubTextureCHROMIUM(const Context *context,
                                                 bool isCallValid,
                                                 TextureID sourceIdPacked,
                                                 GLint sourceLevel,
                                                 TextureTarget destTargetPacked,
                                                 TextureID destIdPacked,
                                                 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
angle::CallCapture CaptureCoverageModulationCHROMIUM(const Context *context,
                                                     bool isCallValid,
                                                     GLenum components);
angle::CallCapture CaptureMatrixLoadfCHROMIUM(const Context *context,
                                              bool isCallValid,
                                              GLenum matrixMode,
                                              const GLfloat *matrix);
angle::CallCapture CaptureMatrixLoadIdentityCHROMIUM(const Context *context,
                                                     bool isCallValid,
                                                     GLenum matrixMode);

// GL_CHROMIUM_lose_context
angle::CallCapture CaptureLoseContextCHROMIUM(const Context *context,
                                              bool isCallValid,
                                              GraphicsResetStatus currentPacked,
                                              GraphicsResetStatus otherPacked);

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

// GL_EXT_blend_func_extended
angle::CallCapture CaptureBindFragDataLocationEXT(const Context *context,
                                                  bool isCallValid,
                                                  GLuint program,
                                                  GLuint color,
                                                  const GLchar *name);
angle::CallCapture CaptureBindFragDataLocationIndexedEXT(const Context *context,
                                                         bool isCallValid,
                                                         GLuint program,
                                                         GLuint colorNumber,
                                                         GLuint index,
                                                         const GLchar *name);
angle::CallCapture CaptureGetFragDataIndexEXT(const Context *context,
                                              bool isCallValid,
                                              GLuint program,
                                              const GLchar *name,
                                              GLint returnValue);
angle::CallCapture CaptureGetProgramResourceLocationIndexEXT(const Context *context,
                                                             bool isCallValid,
                                                             GLuint program,
                                                             GLenum programInterface,
                                                             const GLchar *name,
                                                             GLint returnValue);

// GL_EXT_debug_marker
angle::CallCapture CaptureInsertEventMarkerEXT(const Context *context,
                                               bool isCallValid,
                                               GLsizei length,
                                               const GLchar *marker);
angle::CallCapture CapturePopGroupMarkerEXT(const Context *context, bool isCallValid);
angle::CallCapture CapturePushGroupMarkerEXT(const Context *context,
                                             bool isCallValid,
                                             GLsizei length,
                                             const GLchar *marker);

// GL_EXT_discard_framebuffer
angle::CallCapture CaptureDiscardFramebufferEXT(const Context *context,
                                                bool isCallValid,
                                                GLenum target,
                                                GLsizei numAttachments,
                                                const GLenum *attachments);

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

// GL_EXT_draw_buffers
angle::CallCapture CaptureDrawBuffersEXT(const Context *context,
                                         bool isCallValid,
                                         GLsizei n,
                                         const GLenum *bufs);

// GL_EXT_geometry_shader
angle::CallCapture CaptureFramebufferTextureEXT(const Context *context,
                                                bool isCallValid,
                                                GLenum target,
                                                GLenum attachment,
                                                TextureID texturePacked,
                                                GLint level);

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

// GL_EXT_map_buffer_range
angle::CallCapture CaptureFlushMappedBufferRangeEXT(const Context *context,
                                                    bool isCallValid,
                                                    BufferBinding targetPacked,
                                                    GLintptr offset,
                                                    GLsizeiptr length);
angle::CallCapture CaptureMapBufferRangeEXT(const Context *context,
                                            bool isCallValid,
                                            BufferBinding targetPacked,
                                            GLintptr offset,
                                            GLsizeiptr length,
                                            GLbitfield access,
                                            void *returnValue);

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

// GL_EXT_memory_object_fd
angle::CallCapture CaptureImportMemoryFdEXT(const Context *context,
                                            bool isCallValid,
                                            GLuint memory,
                                            GLuint64 size,
                                            HandleType handleTypePacked,
                                            GLint fd);

// GL_EXT_occlusion_query_boolean

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

// GL_EXT_semaphore
angle::CallCapture CaptureDeleteSemaphoresEXT(const Context *context,
                                              bool isCallValid,
                                              GLsizei n,
                                              const GLuint *semaphores);
angle::CallCapture CaptureGenSemaphoresEXT(const Context *context,
                                           bool isCallValid,
                                           GLsizei n,
                                           GLuint *semaphores);
angle::CallCapture CaptureGetSemaphoreParameterui64vEXT(const Context *context,
                                                        bool isCallValid,
                                                        GLuint semaphore,
                                                        GLenum pname,
                                                        GLuint64 *params);
angle::CallCapture CaptureIsSemaphoreEXT(const Context *context,
                                         bool isCallValid,
                                         GLuint semaphore,
                                         GLboolean returnValue);
angle::CallCapture CaptureSemaphoreParameterui64vEXT(const Context *context,
                                                     bool isCallValid,
                                                     GLuint semaphore,
                                                     GLenum pname,
                                                     const GLuint64 *params);
angle::CallCapture CaptureSignalSemaphoreEXT(const Context *context,
                                             bool isCallValid,
                                             GLuint semaphore,
                                             GLuint numBufferBarriers,
                                             const BufferID *buffersPacked,
                                             GLuint numTextureBarriers,
                                             const TextureID *texturesPacked,
                                             const GLenum *dstLayouts);
angle::CallCapture CaptureWaitSemaphoreEXT(const Context *context,
                                           bool isCallValid,
                                           GLuint semaphore,
                                           GLuint numBufferBarriers,
                                           const BufferID *buffersPacked,
                                           GLuint numTextureBarriers,
                                           const TextureID *texturesPacked,
                                           const GLenum *srcLayouts);

// GL_EXT_semaphore_fd
angle::CallCapture CaptureImportSemaphoreFdEXT(const Context *context,
                                               bool isCallValid,
                                               GLuint semaphore,
                                               HandleType handleTypePacked,
                                               GLint fd);

// GL_EXT_texture_storage
angle::CallCapture CaptureTexStorage1DEXT(const Context *context,
                                          bool isCallValid,
                                          GLenum target,
                                          GLsizei levels,
                                          GLenum internalformat,
                                          GLsizei width);
angle::CallCapture CaptureTexStorage2DEXT(const Context *context,
                                          bool isCallValid,
                                          TextureType targetPacked,
                                          GLsizei levels,
                                          GLenum internalformat,
                                          GLsizei width,
                                          GLsizei height);
angle::CallCapture CaptureTexStorage3DEXT(const Context *context,
                                          bool isCallValid,
                                          TextureType targetPacked,
                                          GLsizei levels,
                                          GLenum internalformat,
                                          GLsizei width,
                                          GLsizei height,
                                          GLsizei depth);

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

// GL_KHR_parallel_shader_compile
angle::CallCapture CaptureMaxShaderCompilerThreadsKHR(const Context *context,
                                                      bool isCallValid,
                                                      GLuint count);

// GL_NV_fence
angle::CallCapture CaptureDeleteFencesNV(const Context *context,
                                         bool isCallValid,
                                         GLsizei n,
                                         const GLuint *fences);
angle::CallCapture CaptureFinishFenceNV(const Context *context, bool isCallValid, GLuint fence);
angle::CallCapture CaptureGenFencesNV(const Context *context,
                                      bool isCallValid,
                                      GLsizei n,
                                      GLuint *fences);
angle::CallCapture CaptureGetFenceivNV(const Context *context,
                                       bool isCallValid,
                                       GLuint fence,
                                       GLenum pname,
                                       GLint *params);
angle::CallCapture CaptureIsFenceNV(const Context *context,
                                    bool isCallValid,
                                    GLuint fence,
                                    GLboolean returnValue);
angle::CallCapture CaptureSetFenceNV(const Context *context,
                                     bool isCallValid,
                                     GLuint fence,
                                     GLenum condition);
angle::CallCapture CaptureTestFenceNV(const Context *context,
                                      bool isCallValid,
                                      GLuint fence,
                                      GLboolean returnValue);

// GL_OES_EGL_image
angle::CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const Context *context,
                                                               bool isCallValid,
                                                               GLenum target,
                                                               GLeglImageOES image);
angle::CallCapture CaptureEGLImageTargetTexture2DOES(const Context *context,
                                                     bool isCallValid,
                                                     TextureType targetPacked,
                                                     GLeglImageOES image);

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

// GL_OES_framebuffer_object
angle::CallCapture CaptureBindFramebufferOES(const Context *context,
                                             bool isCallValid,
                                             GLenum target,
                                             GLuint framebuffer);
angle::CallCapture CaptureBindRenderbufferOES(const Context *context,
                                              bool isCallValid,
                                              GLenum target,
                                              RenderbufferID renderbufferPacked);
angle::CallCapture CaptureCheckFramebufferStatusOES(const Context *context,
                                                    bool isCallValid,
                                                    GLenum target,
                                                    GLenum returnValue);
angle::CallCapture CaptureDeleteFramebuffersOES(const Context *context,
                                                bool isCallValid,
                                                GLsizei n,
                                                const GLuint *framebuffers);
angle::CallCapture CaptureDeleteRenderbuffersOES(const Context *context,
                                                 bool isCallValid,
                                                 GLsizei n,
                                                 const RenderbufferID *renderbuffersPacked);
angle::CallCapture CaptureFramebufferRenderbufferOES(const Context *context,
                                                     bool isCallValid,
                                                     GLenum target,
                                                     GLenum attachment,
                                                     GLenum renderbuffertarget,
                                                     RenderbufferID renderbufferPacked);
angle::CallCapture CaptureFramebufferTexture2DOES(const Context *context,
                                                  bool isCallValid,
                                                  GLenum target,
                                                  GLenum attachment,
                                                  TextureTarget textargetPacked,
                                                  TextureID texturePacked,
                                                  GLint level);
angle::CallCapture CaptureGenFramebuffersOES(const Context *context,
                                             bool isCallValid,
                                             GLsizei n,
                                             GLuint *framebuffers);
angle::CallCapture CaptureGenRenderbuffersOES(const Context *context,
                                              bool isCallValid,
                                              GLsizei n,
                                              RenderbufferID *renderbuffersPacked);
angle::CallCapture CaptureGenerateMipmapOES(const Context *context,
                                            bool isCallValid,
                                            TextureType targetPacked);
angle::CallCapture CaptureGetFramebufferAttachmentParameterivOES(const Context *context,
                                                                 bool isCallValid,
                                                                 GLenum target,
                                                                 GLenum attachment,
                                                                 GLenum pname,
                                                                 GLint *params);
angle::CallCapture CaptureGetRenderbufferParameterivOES(const Context *context,
                                                        bool isCallValid,
                                                        GLenum target,
                                                        GLenum pname,
                                                        GLint *params);
angle::CallCapture CaptureIsFramebufferOES(const Context *context,
                                           bool isCallValid,
                                           GLuint framebuffer,
                                           GLboolean returnValue);
angle::CallCapture CaptureIsRenderbufferOES(const Context *context,
                                            bool isCallValid,
                                            RenderbufferID renderbufferPacked,
                                            GLboolean returnValue);
angle::CallCapture CaptureRenderbufferStorageOES(const Context *context,
                                                 bool isCallValid,
                                                 GLenum target,
                                                 GLenum internalformat,
                                                 GLsizei width,
                                                 GLsizei height);

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

// GL_OES_mapbuffer
angle::CallCapture CaptureGetBufferPointervOES(const Context *context,
                                               bool isCallValid,
                                               BufferBinding targetPacked,
                                               GLenum pname,
                                               void **params);
angle::CallCapture CaptureMapBufferOES(const Context *context,
                                       bool isCallValid,
                                       BufferBinding targetPacked,
                                       GLenum access,
                                       void *returnValue);
angle::CallCapture CaptureUnmapBufferOES(const Context *context,
                                         bool isCallValid,
                                         BufferBinding targetPacked,
                                         GLboolean returnValue);

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

// GL_OES_point_size_array
angle::CallCapture CapturePointSizePointerOES(const Context *context,
                                              bool isCallValid,
                                              VertexAttribType typePacked,
                                              GLsizei stride,
                                              const void *pointer);

// GL_OES_query_matrix
angle::CallCapture CaptureQueryMatrixxOES(const Context *context,
                                          bool isCallValid,
                                          GLfixed *mantissa,
                                          GLint *exponent,
                                          GLbitfield returnValue);

// GL_OES_texture_3D
angle::CallCapture CaptureCompressedTexImage3DOES(const Context *context,
                                                  bool isCallValid,
                                                  TextureTarget targetPacked,
                                                  GLint level,
                                                  GLenum internalformat,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLsizei depth,
                                                  GLint border,
                                                  GLsizei imageSize,
                                                  const void *data);
angle::CallCapture CaptureCompressedTexSubImage3DOES(const Context *context,
                                                     bool isCallValid,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLint xoffset,
                                                     GLint yoffset,
                                                     GLint zoffset,
                                                     GLsizei width,
                                                     GLsizei height,
                                                     GLsizei depth,
                                                     GLenum format,
                                                     GLsizei imageSize,
                                                     const void *data);
angle::CallCapture CaptureCopyTexSubImage3DOES(const Context *context,
                                               bool isCallValid,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLint zoffset,
                                               GLint x,
                                               GLint y,
                                               GLsizei width,
                                               GLsizei height);
angle::CallCapture CaptureFramebufferTexture3DOES(const Context *context,
                                                  bool isCallValid,
                                                  GLenum target,
                                                  GLenum attachment,
                                                  TextureTarget textargetPacked,
                                                  TextureID texturePacked,
                                                  GLint level,
                                                  GLint zoffset);
angle::CallCapture CaptureTexImage3DOES(const Context *context,
                                        bool isCallValid,
                                        TextureTarget targetPacked,
                                        GLint level,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLsizei height,
                                        GLsizei depth,
                                        GLint border,
                                        GLenum format,
                                        GLenum type,
                                        const void *pixels);
angle::CallCapture CaptureTexSubImage3DOES(const Context *context,
                                           bool isCallValid,
                                           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
angle::CallCapture CaptureGetSamplerParameterIivOES(const Context *context,
                                                    bool isCallValid,
                                                    SamplerID samplerPacked,
                                                    GLenum pname,
                                                    GLint *params);
angle::CallCapture CaptureGetSamplerParameterIuivOES(const Context *context,
                                                     bool isCallValid,
                                                     SamplerID samplerPacked,
                                                     GLenum pname,
                                                     GLuint *params);
angle::CallCapture CaptureGetTexParameterIivOES(const Context *context,
                                                bool isCallValid,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLint *params);
angle::CallCapture CaptureGetTexParameterIuivOES(const Context *context,
                                                 bool isCallValid,
                                                 TextureType targetPacked,
                                                 GLenum pname,
                                                 GLuint *params);
angle::CallCapture CaptureSamplerParameterIivOES(const Context *context,
                                                 bool isCallValid,
                                                 SamplerID samplerPacked,
                                                 GLenum pname,
                                                 const GLint *param);
angle::CallCapture CaptureSamplerParameterIuivOES(const Context *context,
                                                  bool isCallValid,
                                                  SamplerID samplerPacked,
                                                  GLenum pname,
                                                  const GLuint *param);
angle::CallCapture CaptureTexParameterIivOES(const Context *context,
                                             bool isCallValid,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             const GLint *params);
angle::CallCapture CaptureTexParameterIuivOES(const Context *context,
                                              bool isCallValid,
                                              TextureType targetPacked,
                                              GLenum pname,
                                              const GLuint *params);

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

// GL_OES_texture_storage_multisample_2d_array
angle::CallCapture CaptureTexStorage3DMultisampleOES(const Context *context,
                                                     bool isCallValid,
                                                     TextureType targetPacked,
                                                     GLsizei samples,
                                                     GLenum internalformat,
                                                     GLsizei width,
                                                     GLsizei height,
                                                     GLsizei depth,
                                                     GLboolean fixedsamplelocations);

// GL_OES_vertex_array_object
angle::CallCapture CaptureBindVertexArrayOES(const Context *context,
                                             bool isCallValid,
                                             GLuint array);
angle::CallCapture CaptureDeleteVertexArraysOES(const Context *context,
                                                bool isCallValid,
                                                GLsizei n,
                                                const GLuint *arrays);
angle::CallCapture CaptureGenVertexArraysOES(const Context *context,
                                             bool isCallValid,
                                             GLsizei n,
                                             GLuint *arrays);
angle::CallCapture CaptureIsVertexArrayOES(const Context *context,
                                           bool isCallValid,
                                           GLuint array,
                                           GLboolean returnValue);

// GL_OVR_multiview
angle::CallCapture CaptureFramebufferTextureMultiviewOVR(const Context *context,
                                                         bool isCallValid,
                                                         GLenum target,
                                                         GLenum attachment,
                                                         TextureID texturePacked,
                                                         GLint level,
                                                         GLint baseViewIndex,
                                                         GLsizei numViews);

// GL_OVR_multiview2

// Parameter Captures

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

#endif  // LIBANGLE_CAPTURE_GLES_ext_AUTOGEN_H_
