// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
//
// Copyright 2020 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
{

// Method Captures

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

// GL_ANGLE_copy_texture_3d
angle::CallCapture CaptureCopyTexture3DANGLE(const State &glState,
                                             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 State &glState,
                                                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 State &glState,
                                               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 State &glState,
                                                              bool isCallValid,
                                                              GLenum target,
                                                              GLsizei samples,
                                                              GLenum internalformat,
                                                              GLsizei width,
                                                              GLsizei height);

// GL_ANGLE_get_image
angle::CallCapture CaptureGetTexImageANGLE(const State &glState,
                                           bool isCallValid,
                                           TextureTarget targetPacked,
                                           GLint level,
                                           GLenum format,
                                           GLenum type,
                                           void *pixels);
angle::CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
                                                    bool isCallValid,
                                                    GLenum target,
                                                    GLenum format,
                                                    GLenum type,
                                                    void *pixels);

// GL_ANGLE_get_tex_level_parameter
angle::CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState,
                                                      bool isCallValid,
                                                      TextureTarget targetPacked,
                                                      GLint level,
                                                      GLenum pname,
                                                      GLint *params);
angle::CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState,
                                                      bool isCallValid,
                                                      TextureTarget targetPacked,
                                                      GLint level,
                                                      GLenum pname,
                                                      GLfloat *params);

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

// GL_ANGLE_memory_object_flags
angle::CallCapture CaptureTexStorageMemFlags2DANGLE(const State &glState,
                                                    bool isCallValid,
                                                    TextureType targetPacked,
                                                    GLsizei levels,
                                                    GLenum internalFormat,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    MemoryObjectID memoryPacked,
                                                    GLuint64 offset,
                                                    GLbitfield createFlags,
                                                    GLbitfield usageFlags);
angle::CallCapture CaptureTexStorageMemFlags2DMultisampleANGLE(const State &glState,
                                                               bool isCallValid,
                                                               TextureType targetPacked,
                                                               GLsizei samples,
                                                               GLenum internalFormat,
                                                               GLsizei width,
                                                               GLsizei height,
                                                               GLboolean fixedSampleLocations,
                                                               MemoryObjectID memoryPacked,
                                                               GLuint64 offset,
                                                               GLbitfield createFlags,
                                                               GLbitfield usageFlags);
angle::CallCapture CaptureTexStorageMemFlags3DANGLE(const State &glState,
                                                    bool isCallValid,
                                                    TextureType targetPacked,
                                                    GLsizei levels,
                                                    GLenum internalFormat,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLsizei depth,
                                                    MemoryObjectID memoryPacked,
                                                    GLuint64 offset,
                                                    GLbitfield createFlags,
                                                    GLbitfield usageFlags);
angle::CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState,
                                                               bool isCallValid,
                                                               TextureType targetPacked,
                                                               GLsizei samples,
                                                               GLenum internalFormat,
                                                               GLsizei width,
                                                               GLsizei height,
                                                               GLsizei depth,
                                                               GLboolean fixedSampleLocations,
                                                               MemoryObjectID memoryPacked,
                                                               GLuint64 offset,
                                                               GLbitfield createFlags,
                                                               GLbitfield usageFlags);

// GL_ANGLE_memory_object_fuchsia
angle::CallCapture CaptureImportMemoryZirconHandleANGLE(const State &glState,
                                                        bool isCallValid,
                                                        MemoryObjectID memoryPacked,
                                                        GLuint64 size,
                                                        HandleType handleTypePacked,
                                                        GLuint handle);

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

// GL_ANGLE_program_binary

// GL_ANGLE_provoking_vertex
angle::CallCapture CaptureProvokingVertexANGLE(const State &glState,
                                               bool isCallValid,
                                               ProvokingVertexConvention modePacked);

// GL_ANGLE_request_extension
angle::CallCapture CaptureRequestExtensionANGLE(const State &glState,
                                                bool isCallValid,
                                                const GLchar *name);
angle::CallCapture CaptureDisableExtensionANGLE(const State &glState,
                                                bool isCallValid,
                                                const GLchar *name);

// GL_ANGLE_robust_client_memory
angle::CallCapture CaptureGetBooleanvRobustANGLE(const State &glState,
                                                 bool isCallValid,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLboolean *params);
angle::CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState,
                                                          bool isCallValid,
                                                          BufferBinding targetPacked,
                                                          GLenum pname,
                                                          GLsizei bufSize,
                                                          GLsizei *length,
                                                          GLint *params);
angle::CallCapture CaptureGetFloatvRobustANGLE(const State &glState,
                                               bool isCallValid,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLfloat *params);
angle::CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState,
                                                                         bool isCallValid,
                                                                         GLenum target,
                                                                         GLenum attachment,
                                                                         GLenum pname,
                                                                         GLsizei bufSize,
                                                                         GLsizei *length,
                                                                         GLint *params);
angle::CallCapture CaptureGetIntegervRobustANGLE(const State &glState,
                                                 bool isCallValid,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *data);
angle::CallCapture CaptureGetProgramivRobustANGLE(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLint *params);
angle::CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState,
                                                                bool isCallValid,
                                                                GLenum target,
                                                                GLenum pname,
                                                                GLsizei bufSize,
                                                                GLsizei *length,
                                                                GLint *params);
angle::CallCapture CaptureGetShaderivRobustANGLE(const State &glState,
                                                 bool isCallValid,
                                                 ShaderProgramID shaderPacked,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params);
angle::CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       TextureType targetPacked,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLfloat *params);
angle::CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       TextureType targetPacked,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLint *params);
angle::CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  UniformLocation locationPacked,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLfloat *params);
angle::CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  UniformLocation locationPacked,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLint *params);
angle::CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       GLuint index,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLfloat *params);
angle::CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       GLuint index,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLint *params);
angle::CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState,
                                                             bool isCallValid,
                                                             GLuint index,
                                                             GLenum pname,
                                                             GLsizei bufSize,
                                                             GLsizei *length,
                                                             void **pointer);
angle::CallCapture CaptureReadPixelsRobustANGLE(const State &glState,
                                                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 State &glState,
                                                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 State &glState,
                                                    bool isCallValid,
                                                    TextureType targetPacked,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    const GLfloat *params);
angle::CallCapture CaptureTexParameterivRobustANGLE(const State &glState,
                                                    bool isCallValid,
                                                    TextureType targetPacked,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    const GLint *params);
angle::CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState,
                                                   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 State &glState,
                                                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 State &glState,
                                                   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 State &glState,
                                                          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 State &glState,
                                                             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 State &glState,
                                                          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 State &glState,
                                                             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 State &glState,
                                                bool isCallValid,
                                                QueryType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params);
angle::CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       QueryID idPacked,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLuint *params);
angle::CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       BufferBinding targetPacked,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       void **params);
angle::CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   GLenum target,
                                                   GLuint index,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint *data);
angle::CallCapture CaptureGetInternalformativRobustANGLE(const State &glState,
                                                         bool isCallValid,
                                                         GLenum target,
                                                         GLenum internalformat,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLint *params);
angle::CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        GLuint index,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *params);
angle::CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState,
                                                         bool isCallValid,
                                                         GLuint index,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLuint *params);
angle::CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
                                                   UniformLocation locationPacked,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLuint *params);
angle::CallCapture CaptureGetActiveUniformBlockivRobustANGLE(const State &glState,
                                                             bool isCallValid,
                                                             ShaderProgramID programPacked,
                                                             GLuint uniformBlockIndex,
                                                             GLenum pname,
                                                             GLsizei bufSize,
                                                             GLsizei *length,
                                                             GLint *params);
angle::CallCapture CaptureGetInteger64vRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint64 *data);
angle::CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState,
                                                     bool isCallValid,
                                                     GLenum target,
                                                     GLuint index,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint64 *data);
angle::CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState,
                                                            bool isCallValid,
                                                            BufferBinding targetPacked,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLint64 *params);
angle::CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        SamplerID samplerPacked,
                                                        GLuint pname,
                                                        GLsizei bufSize,
                                                        const GLint *param);
angle::CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        SamplerID samplerPacked,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        const GLfloat *param);
angle::CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState,
                                                           bool isCallValid,
                                                           SamplerID samplerPacked,
                                                           GLenum pname,
                                                           GLsizei bufSize,
                                                           GLsizei *length,
                                                           GLint *params);
angle::CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState,
                                                           bool isCallValid,
                                                           SamplerID samplerPacked,
                                                           GLenum pname,
                                                           GLsizei bufSize,
                                                           GLsizei *length,
                                                           GLfloat *params);
angle::CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState,
                                                               bool isCallValid,
                                                               GLenum target,
                                                               GLenum pname,
                                                               GLsizei bufSize,
                                                               GLsizei *length,
                                                               GLint *params);
angle::CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState,
                                                           bool isCallValid,
                                                           ShaderProgramID programPacked,
                                                           GLenum programInterface,
                                                           GLenum pname,
                                                           GLsizei bufSize,
                                                           GLsizei *length,
                                                           GLint *params);
angle::CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   GLenum target,
                                                   GLuint index,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLboolean *data);
angle::CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState,
                                                      bool isCallValid,
                                                      GLenum pname,
                                                      GLuint index,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLfloat *val);
angle::CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState,
                                                            bool isCallValid,
                                                            TextureTarget targetPacked,
                                                            GLint level,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLint *params);
angle::CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState,
                                                            bool isCallValid,
                                                            TextureTarget targetPacked,
                                                            GLint level,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLfloat *params);
angle::CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState,
                                                            bool isCallValid,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            void **params);
angle::CallCapture CaptureReadnPixelsRobustANGLE(const State &glState,
                                                 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 State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
                                                   UniformLocation locationPacked,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLfloat *params);
angle::CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
                                                   UniformLocation locationPacked,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint *params);
angle::CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    UniformLocation locationPacked,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLuint *params);
angle::CallCapture CaptureTexParameterIivRobustANGLE(const State &glState,
                                                     bool isCallValid,
                                                     TextureType targetPacked,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     const GLint *params);
angle::CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState,
                                                      bool isCallValid,
                                                      TextureType targetPacked,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      const GLuint *params);
angle::CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        TextureType targetPacked,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *params);
angle::CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState,
                                                         bool isCallValid,
                                                         TextureType targetPacked,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLuint *params);
angle::CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState,
                                                         bool isCallValid,
                                                         SamplerID samplerPacked,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         const GLint *param);
angle::CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState,
                                                          bool isCallValid,
                                                          SamplerID samplerPacked,
                                                          GLenum pname,
                                                          GLsizei bufSize,
                                                          const GLuint *param);
angle::CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState,
                                                            bool isCallValid,
                                                            SamplerID samplerPacked,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLint *params);
angle::CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState,
                                                             bool isCallValid,
                                                             SamplerID samplerPacked,
                                                             GLenum pname,
                                                             GLsizei bufSize,
                                                             GLsizei *length,
                                                             GLuint *params);
angle::CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState,
                                                      bool isCallValid,
                                                      QueryID idPacked,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLint *params);
angle::CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        QueryID idPacked,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint64 *params);
angle::CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState,
                                                         bool isCallValid,
                                                         QueryID idPacked,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLuint64 *params);

// GL_ANGLE_semaphore_fuchsia
angle::CallCapture CaptureImportSemaphoreZirconHandleANGLE(const State &glState,
                                                           bool isCallValid,
                                                           SemaphoreID semaphorePacked,
                                                           HandleType handleTypePacked,
                                                           GLuint handle);

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

// GL_ANGLE_texture_multisample
angle::CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState,
                                                       bool isCallValid,
                                                       TextureType targetPacked,
                                                       GLsizei samples,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLboolean fixedsamplelocations);
angle::CallCapture CaptureGetMultisamplefvANGLE(const State &glState,
                                                bool isCallValid,
                                                GLenum pname,
                                                GLuint index,
                                                GLfloat *val);
angle::CallCapture CaptureSampleMaskiANGLE(const State &glState,
                                           bool isCallValid,
                                           GLuint maskNumber,
                                           GLbitfield mask);

// GL_ANGLE_translated_shader_source
angle::CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
                                                         bool isCallValid,
                                                         ShaderProgramID shaderPacked,
                                                         GLsizei bufsize,
                                                         GLsizei *length,
                                                         GLchar *source);

// GL_CHROMIUM_bind_uniform_location
angle::CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
                                                      bool isCallValid,
                                                      ShaderProgramID programPacked,
                                                      UniformLocation locationPacked,
                                                      const GLchar *name);

// GL_CHROMIUM_copy_compressed_texture
angle::CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState,
                                                        bool isCallValid,
                                                        TextureID sourceIdPacked,
                                                        TextureID destIdPacked);

// GL_CHROMIUM_copy_texture
angle::CallCapture CaptureCopyTextureCHROMIUM(const State &glState,
                                              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 State &glState,
                                                 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 State &glState,
                                                     bool isCallValid,
                                                     GLenum components);

// GL_CHROMIUM_lose_context
angle::CallCapture CaptureLoseContextCHROMIUM(const State &glState,
                                              bool isCallValid,
                                              GraphicsResetStatus currentPacked,
                                              GraphicsResetStatus otherPacked);

// GL_EXT_EGL_image_array

// GL_EXT_blend_func_extended
angle::CallCapture CaptureBindFragDataLocationEXT(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLuint color,
                                                  const GLchar *name);
angle::CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState,
                                                         bool isCallValid,
                                                         ShaderProgramID programPacked,
                                                         GLuint colorNumber,
                                                         GLuint index,
                                                         const GLchar *name);
angle::CallCapture CaptureGetFragDataIndexEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              const GLchar *name,
                                              GLint returnValue);
angle::CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState,
                                                             bool isCallValid,
                                                             ShaderProgramID programPacked,
                                                             GLenum programInterface,
                                                             const GLchar *name,
                                                             GLint returnValue);

// GL_EXT_buffer_storage
angle::CallCapture CaptureBufferStorageEXT(const State &glState,
                                           bool isCallValid,
                                           BufferBinding targetPacked,
                                           GLsizeiptr size,
                                           const void *data,
                                           GLbitfield flags);

// GL_EXT_copy_image
angle::CallCapture CaptureCopyImageSubDataEXT(const State &glState,
                                              bool isCallValid,
                                              GLuint srcName,
                                              GLenum srcTarget,
                                              GLint srcLevel,
                                              GLint srcX,
                                              GLint srcY,
                                              GLint srcZ,
                                              GLuint dstName,
                                              GLenum dstTarget,
                                              GLint dstLevel,
                                              GLint dstX,
                                              GLint dstY,
                                              GLint dstZ,
                                              GLsizei srcWidth,
                                              GLsizei srcHeight,
                                              GLsizei srcDepth);

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

// GL_EXT_discard_framebuffer
angle::CallCapture CaptureDiscardFramebufferEXT(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                GLsizei numAttachments,
                                                const GLenum *attachments);

// GL_EXT_disjoint_timer_query
angle::CallCapture CaptureBeginQueryEXT(const State &glState,
                                        bool isCallValid,
                                        QueryType targetPacked,
                                        QueryID idPacked);
angle::CallCapture CaptureDeleteQueriesEXT(const State &glState,
                                           bool isCallValid,
                                           GLsizei n,
                                           const QueryID *idsPacked);
angle::CallCapture CaptureEndQueryEXT(const State &glState,
                                      bool isCallValid,
                                      QueryType targetPacked);
angle::CallCapture CaptureGenQueriesEXT(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        QueryID *idsPacked);
angle::CallCapture CaptureGetInteger64vEXT(const State &glState,
                                           bool isCallValid,
                                           GLenum pname,
                                           GLint64 *data);
angle::CallCapture CaptureGetQueryObjecti64vEXT(const State &glState,
                                                bool isCallValid,
                                                QueryID idPacked,
                                                GLenum pname,
                                                GLint64 *params);
angle::CallCapture CaptureGetQueryObjectivEXT(const State &glState,
                                              bool isCallValid,
                                              QueryID idPacked,
                                              GLenum pname,
                                              GLint *params);
angle::CallCapture CaptureGetQueryObjectui64vEXT(const State &glState,
                                                 bool isCallValid,
                                                 QueryID idPacked,
                                                 GLenum pname,
                                                 GLuint64 *params);
angle::CallCapture CaptureGetQueryObjectuivEXT(const State &glState,
                                               bool isCallValid,
                                               QueryID idPacked,
                                               GLenum pname,
                                               GLuint *params);
angle::CallCapture CaptureGetQueryivEXT(const State &glState,
                                        bool isCallValid,
                                        QueryType targetPacked,
                                        GLenum pname,
                                        GLint *params);
angle::CallCapture CaptureIsQueryEXT(const State &glState,
                                     bool isCallValid,
                                     QueryID idPacked,
                                     GLboolean returnValue);
angle::CallCapture CaptureQueryCounterEXT(const State &glState,
                                          bool isCallValid,
                                          QueryID idPacked,
                                          QueryType targetPacked);

// GL_EXT_draw_buffers
angle::CallCapture CaptureDrawBuffersEXT(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         const GLenum *bufs);

// GL_EXT_draw_buffers_indexed
angle::CallCapture CaptureBlendEquationSeparateiEXT(const State &glState,
                                                    bool isCallValid,
                                                    GLuint buf,
                                                    GLenum modeRGB,
                                                    GLenum modeAlpha);
angle::CallCapture CaptureBlendEquationiEXT(const State &glState,
                                            bool isCallValid,
                                            GLuint buf,
                                            GLenum mode);
angle::CallCapture CaptureBlendFuncSeparateiEXT(const State &glState,
                                                bool isCallValid,
                                                GLuint buf,
                                                GLenum srcRGB,
                                                GLenum dstRGB,
                                                GLenum srcAlpha,
                                                GLenum dstAlpha);
angle::CallCapture CaptureBlendFunciEXT(const State &glState,
                                        bool isCallValid,
                                        GLuint buf,
                                        GLenum src,
                                        GLenum dst);
angle::CallCapture CaptureColorMaskiEXT(const State &glState,
                                        bool isCallValid,
                                        GLuint index,
                                        GLboolean r,
                                        GLboolean g,
                                        GLboolean b,
                                        GLboolean a);
angle::CallCapture CaptureDisableiEXT(const State &glState,
                                      bool isCallValid,
                                      GLenum target,
                                      GLuint index);
angle::CallCapture CaptureEnableiEXT(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLuint index);
angle::CallCapture CaptureIsEnablediEXT(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLuint index,
                                        GLboolean returnValue);

// GL_EXT_draw_elements_base_vertex
angle::CallCapture CaptureDrawElementsBaseVertexEXT(const State &glState,
                                                    bool isCallValid,
                                                    PrimitiveMode modePacked,
                                                    GLsizei count,
                                                    DrawElementsType typePacked,
                                                    const void *indices,
                                                    GLint basevertex);
angle::CallCapture CaptureDrawElementsInstancedBaseVertexEXT(const State &glState,
                                                             bool isCallValid,
                                                             PrimitiveMode modePacked,
                                                             GLsizei count,
                                                             DrawElementsType typePacked,
                                                             const void *indices,
                                                             GLsizei instancecount,
                                                             GLint basevertex);
angle::CallCapture CaptureDrawRangeElementsBaseVertexEXT(const State &glState,
                                                         bool isCallValid,
                                                         PrimitiveMode modePacked,
                                                         GLuint start,
                                                         GLuint end,
                                                         GLsizei count,
                                                         DrawElementsType typePacked,
                                                         const void *indices,
                                                         GLint basevertex);
angle::CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState,
                                                         bool isCallValid,
                                                         PrimitiveMode modePacked,
                                                         const GLsizei *count,
                                                         DrawElementsType typePacked,
                                                         const void *const *indices,
                                                         GLsizei primcount,
                                                         const GLint *basevertex);

// GL_EXT_external_buffer
angle::CallCapture CaptureBufferStorageExternalEXT(const State &glState,
                                                   bool isCallValid,
                                                   BufferBinding targetPacked,
                                                   GLintptr offset,
                                                   GLsizeiptr size,
                                                   GLeglClientBufferEXT clientBuffer,
                                                   GLbitfield flags);
angle::CallCapture CaptureNamedBufferStorageExternalEXT(const State &glState,
                                                        bool isCallValid,
                                                        GLuint buffer,
                                                        GLintptr offset,
                                                        GLsizeiptr size,
                                                        GLeglClientBufferEXT clientBuffer,
                                                        GLbitfield flags);

// GL_EXT_geometry_shader
angle::CallCapture CaptureFramebufferTextureEXT(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                GLenum attachment,
                                                TextureID texturePacked,
                                                GLint level);

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

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

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

// GL_EXT_memory_object_fd
angle::CallCapture CaptureImportMemoryFdEXT(const State &glState,
                                            bool isCallValid,
                                            MemoryObjectID memoryPacked,
                                            GLuint64 size,
                                            HandleType handleTypePacked,
                                            GLint fd);

// GL_EXT_multisampled_render_to_texture
angle::CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState,
                                                             bool isCallValid,
                                                             GLenum target,
                                                             GLenum attachment,
                                                             TextureTarget textargetPacked,
                                                             TextureID texturePacked,
                                                             GLint level,
                                                             GLsizei samples);
angle::CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState,
                                                            bool isCallValid,
                                                            GLenum target,
                                                            GLsizei samples,
                                                            GLenum internalformat,
                                                            GLsizei width,
                                                            GLsizei height);

// GL_EXT_occlusion_query_boolean

// GL_EXT_read_format_bgra

// GL_EXT_robustness
angle::CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState,
                                                    bool isCallValid,
                                                    GLenum returnValue);
angle::CallCapture CaptureGetnUniformfvEXT(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLfloat *params);
angle::CallCapture CaptureGetnUniformivEXT(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLint *params);
angle::CallCapture CaptureReadnPixelsEXT(const State &glState,
                                         bool isCallValid,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         void *data);

// GL_EXT_sRGB

// GL_EXT_semaphore
angle::CallCapture CaptureDeleteSemaphoresEXT(const State &glState,
                                              bool isCallValid,
                                              GLsizei n,
                                              const SemaphoreID *semaphoresPacked);
angle::CallCapture CaptureGenSemaphoresEXT(const State &glState,
                                           bool isCallValid,
                                           GLsizei n,
                                           SemaphoreID *semaphoresPacked);
angle::CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState,
                                                        bool isCallValid,
                                                        SemaphoreID semaphorePacked,
                                                        GLenum pname,
                                                        GLuint64 *params);
angle::CallCapture CaptureIsSemaphoreEXT(const State &glState,
                                         bool isCallValid,
                                         SemaphoreID semaphorePacked,
                                         GLboolean returnValue);
angle::CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState,
                                                     bool isCallValid,
                                                     SemaphoreID semaphorePacked,
                                                     GLenum pname,
                                                     const GLuint64 *params);
angle::CallCapture CaptureSignalSemaphoreEXT(const State &glState,
                                             bool isCallValid,
                                             SemaphoreID semaphorePacked,
                                             GLuint numBufferBarriers,
                                             const BufferID *buffersPacked,
                                             GLuint numTextureBarriers,
                                             const TextureID *texturesPacked,
                                             const GLenum *dstLayouts);
angle::CallCapture CaptureWaitSemaphoreEXT(const State &glState,
                                           bool isCallValid,
                                           SemaphoreID semaphorePacked,
                                           GLuint numBufferBarriers,
                                           const BufferID *buffersPacked,
                                           GLuint numTextureBarriers,
                                           const TextureID *texturesPacked,
                                           const GLenum *srcLayouts);

// GL_EXT_semaphore_fd
angle::CallCapture CaptureImportSemaphoreFdEXT(const State &glState,
                                               bool isCallValid,
                                               SemaphoreID semaphorePacked,
                                               HandleType handleTypePacked,
                                               GLint fd);

// GL_EXT_texture_buffer
angle::CallCapture CaptureTexBufferEXT(const State &glState,
                                       bool isCallValid,
                                       TextureType targetPacked,
                                       GLenum internalformat,
                                       BufferID bufferPacked);
angle::CallCapture CaptureTexBufferRangeEXT(const State &glState,
                                            bool isCallValid,
                                            TextureType targetPacked,
                                            GLenum internalformat,
                                            BufferID bufferPacked,
                                            GLintptr offset,
                                            GLsizeiptr size);

// GL_EXT_texture_compression_bptc

// GL_EXT_texture_compression_dxt1

// GL_EXT_texture_compression_rgtc

// GL_EXT_texture_compression_s3tc

// GL_EXT_texture_compression_s3tc_srgb

// GL_EXT_texture_cube_map_array

// GL_EXT_texture_filter_anisotropic

// GL_EXT_texture_format_BGRA8888

// GL_EXT_texture_sRGB_R8

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

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

// GL_KHR_parallel_shader_compile
angle::CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState,
                                                      bool isCallValid,
                                                      GLuint count);

// GL_NV_fence
angle::CallCapture CaptureDeleteFencesNV(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         const FenceNVID *fencesPacked);
angle::CallCapture CaptureFinishFenceNV(const State &glState,
                                        bool isCallValid,
                                        FenceNVID fencePacked);
angle::CallCapture CaptureGenFencesNV(const State &glState,
                                      bool isCallValid,
                                      GLsizei n,
                                      FenceNVID *fencesPacked);
angle::CallCapture CaptureGetFenceivNV(const State &glState,
                                       bool isCallValid,
                                       FenceNVID fencePacked,
                                       GLenum pname,
                                       GLint *params);
angle::CallCapture CaptureIsFenceNV(const State &glState,
                                    bool isCallValid,
                                    FenceNVID fencePacked,
                                    GLboolean returnValue);
angle::CallCapture CaptureSetFenceNV(const State &glState,
                                     bool isCallValid,
                                     FenceNVID fencePacked,
                                     GLenum condition);
angle::CallCapture CaptureTestFenceNV(const State &glState,
                                      bool isCallValid,
                                      FenceNVID fencePacked,
                                      GLboolean returnValue);

// GL_OES_EGL_image
angle::CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
                                                               bool isCallValid,
                                                               GLenum target,
                                                               GLeglImageOES image);
angle::CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
                                                     bool isCallValid,
                                                     TextureType targetPacked,
                                                     GLeglImageOES image);

// GL_OES_compressed_ETC1_RGB8_texture

// GL_OES_copy_image
angle::CallCapture CaptureCopyImageSubDataOES(const State &glState,
                                              bool isCallValid,
                                              GLuint srcName,
                                              GLenum srcTarget,
                                              GLint srcLevel,
                                              GLint srcX,
                                              GLint srcY,
                                              GLint srcZ,
                                              GLuint dstName,
                                              GLenum dstTarget,
                                              GLint dstLevel,
                                              GLint dstX,
                                              GLint dstY,
                                              GLint dstZ,
                                              GLsizei srcWidth,
                                              GLsizei srcHeight,
                                              GLsizei srcDepth);

// GL_OES_depth32

// GL_OES_draw_buffers_indexed
angle::CallCapture CaptureBlendEquationSeparateiOES(const State &glState,
                                                    bool isCallValid,
                                                    GLuint buf,
                                                    GLenum modeRGB,
                                                    GLenum modeAlpha);
angle::CallCapture CaptureBlendEquationiOES(const State &glState,
                                            bool isCallValid,
                                            GLuint buf,
                                            GLenum mode);
angle::CallCapture CaptureBlendFuncSeparateiOES(const State &glState,
                                                bool isCallValid,
                                                GLuint buf,
                                                GLenum srcRGB,
                                                GLenum dstRGB,
                                                GLenum srcAlpha,
                                                GLenum dstAlpha);
angle::CallCapture CaptureBlendFunciOES(const State &glState,
                                        bool isCallValid,
                                        GLuint buf,
                                        GLenum src,
                                        GLenum dst);
angle::CallCapture CaptureColorMaskiOES(const State &glState,
                                        bool isCallValid,
                                        GLuint index,
                                        GLboolean r,
                                        GLboolean g,
                                        GLboolean b,
                                        GLboolean a);
angle::CallCapture CaptureDisableiOES(const State &glState,
                                      bool isCallValid,
                                      GLenum target,
                                      GLuint index);
angle::CallCapture CaptureEnableiOES(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLuint index);
angle::CallCapture CaptureIsEnablediOES(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLuint index,
                                        GLboolean returnValue);

// GL_OES_draw_elements_base_vertex
angle::CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
                                                    bool isCallValid,
                                                    PrimitiveMode modePacked,
                                                    GLsizei count,
                                                    DrawElementsType typePacked,
                                                    const void *indices,
                                                    GLint basevertex);
angle::CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
                                                             bool isCallValid,
                                                             PrimitiveMode modePacked,
                                                             GLsizei count,
                                                             DrawElementsType typePacked,
                                                             const void *indices,
                                                             GLsizei instancecount,
                                                             GLint basevertex);
angle::CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
                                                         bool isCallValid,
                                                         PrimitiveMode modePacked,
                                                         GLuint start,
                                                         GLuint end,
                                                         GLsizei count,
                                                         DrawElementsType typePacked,
                                                         const void *indices,
                                                         GLint basevertex);

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

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

// GL_OES_get_program_binary
angle::CallCapture CaptureGetProgramBinaryOES(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLenum *binaryFormat,
                                              void *binary);
angle::CallCapture CaptureProgramBinaryOES(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           GLenum binaryFormat,
                                           const void *binary,
                                           GLint length);

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

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

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

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

// GL_OES_sample_shading
angle::CallCapture CaptureMinSampleShadingOES(const State &glState,
                                              bool isCallValid,
                                              GLfloat value);

// GL_OES_texture_3D
angle::CallCapture CaptureCompressedTexImage3DOES(const State &glState,
                                                  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 State &glState,
                                                     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 State &glState,
                                               bool isCallValid,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLint zoffset,
                                               GLint x,
                                               GLint y,
                                               GLsizei width,
                                               GLsizei height);
angle::CallCapture CaptureFramebufferTexture3DOES(const State &glState,
                                                  bool isCallValid,
                                                  GLenum target,
                                                  GLenum attachment,
                                                  TextureTarget textargetPacked,
                                                  TextureID texturePacked,
                                                  GLint level,
                                                  GLint zoffset);
angle::CallCapture CaptureTexImage3DOES(const State &glState,
                                        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 State &glState,
                                           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 State &glState,
                                                    bool isCallValid,
                                                    SamplerID samplerPacked,
                                                    GLenum pname,
                                                    GLint *params);
angle::CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
                                                     bool isCallValid,
                                                     SamplerID samplerPacked,
                                                     GLenum pname,
                                                     GLuint *params);
angle::CallCapture CaptureGetTexParameterIivOES(const State &glState,
                                                bool isCallValid,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLint *params);
angle::CallCapture CaptureGetTexParameterIuivOES(const State &glState,
                                                 bool isCallValid,
                                                 TextureType targetPacked,
                                                 GLenum pname,
                                                 GLuint *params);
angle::CallCapture CaptureSamplerParameterIivOES(const State &glState,
                                                 bool isCallValid,
                                                 SamplerID samplerPacked,
                                                 GLenum pname,
                                                 const GLint *param);
angle::CallCapture CaptureSamplerParameterIuivOES(const State &glState,
                                                  bool isCallValid,
                                                  SamplerID samplerPacked,
                                                  GLenum pname,
                                                  const GLuint *param);
angle::CallCapture CaptureTexParameterIivOES(const State &glState,
                                             bool isCallValid,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             const GLint *params);
angle::CallCapture CaptureTexParameterIuivOES(const State &glState,
                                              bool isCallValid,
                                              TextureType targetPacked,
                                              GLenum pname,
                                              const GLuint *params);

// GL_OES_texture_buffer
angle::CallCapture CaptureTexBufferOES(const State &glState,
                                       bool isCallValid,
                                       TextureType targetPacked,
                                       GLenum internalformat,
                                       BufferID bufferPacked);
angle::CallCapture CaptureTexBufferRangeOES(const State &glState,
                                            bool isCallValid,
                                            TextureType targetPacked,
                                            GLenum internalformat,
                                            BufferID bufferPacked,
                                            GLintptr offset,
                                            GLsizeiptr size);

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

// GL_OES_texture_cube_map_array

// GL_OES_texture_half_float

// GL_OES_texture_stencil8

// GL_OES_texture_storage_multisample_2d_array
angle::CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
                                                     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 State &glState,
                                             bool isCallValid,
                                             VertexArrayID arrayPacked);
angle::CallCapture CaptureDeleteVertexArraysOES(const State &glState,
                                                bool isCallValid,
                                                GLsizei n,
                                                const VertexArrayID *arraysPacked);
angle::CallCapture CaptureGenVertexArraysOES(const State &glState,
                                             bool isCallValid,
                                             GLsizei n,
                                             VertexArrayID *arraysPacked);
angle::CallCapture CaptureIsVertexArrayOES(const State &glState,
                                           bool isCallValid,
                                           VertexArrayID arrayPacked,
                                           GLboolean returnValue);

// GL_OVR_multiview
angle::CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
                                                         bool isCallValid,
                                                         GLenum target,
                                                         GLenum attachment,
                                                         TextureID texturePacked,
                                                         GLint level,
                                                         GLint baseViewIndex,
                                                         GLsizei numViews);

// GL_OVR_multiview2

// Parameter Captures

void CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    GLsizei count,
    DrawElementsType typePacked,
    const GLvoid *indices,
    GLsizei instanceCounts,
    GLint baseVertex,
    GLuint baseInstance,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(const State &glState,
                                                             bool isCallValid,
                                                             PrimitiveMode modePacked,
                                                             const GLint *firsts,
                                                             const GLsizei *counts,
                                                             const GLsizei *instanceCounts,
                                                             const GLuint *baseInstances,
                                                             GLsizei drawcount,
                                                             angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_counts(const State &glState,
                                                             bool isCallValid,
                                                             PrimitiveMode modePacked,
                                                             const GLint *firsts,
                                                             const GLsizei *counts,
                                                             const GLsizei *instanceCounts,
                                                             const GLuint *baseInstances,
                                                             GLsizei drawcount,
                                                             angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_instanceCounts(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    const GLint *firsts,
    const GLsizei *counts,
    const GLsizei *instanceCounts,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_baseInstances(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    const GLint *firsts,
    const GLsizei *counts,
    const GLsizei *instanceCounts,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_counts(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const GLvoid *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const GLvoid *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const GLvoid *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const GLvoid *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const GLvoid *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureGetTexImageANGLE_pixels(const State &glState,
                                    bool isCallValid,
                                    TextureTarget targetPacked,
                                    GLint level,
                                    GLenum format,
                                    GLenum type,
                                    void *pixels,
                                    angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferImageANGLE_pixels(const State &glState,
                                             bool isCallValid,
                                             GLenum target,
                                             GLenum format,
                                             GLenum type,
                                             void *pixels,
                                             angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivANGLE_params(const State &glState,
                                               bool isCallValid,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLenum pname,
                                               GLint *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvANGLE_params(const State &glState,
                                               bool isCallValid,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               GLenum pname,
                                               GLfloat *params,
                                               angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedANGLE_indices(const State &glState,
                                               bool isCallValid,
                                               PrimitiveMode modePacked,
                                               GLsizei count,
                                               DrawElementsType typePacked,
                                               const void *indices,
                                               GLsizei primcount,
                                               angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysANGLE_firsts(const State &glState,
                                        bool isCallValid,
                                        PrimitiveMode modePacked,
                                        const GLint *firsts,
                                        const GLsizei *counts,
                                        GLsizei drawcount,
                                        angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysANGLE_counts(const State &glState,
                                        bool isCallValid,
                                        PrimitiveMode modePacked,
                                        const GLint *firsts,
                                        const GLsizei *counts,
                                        GLsizei drawcount,
                                        angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_firsts(const State &glState,
                                                 bool isCallValid,
                                                 PrimitiveMode modePacked,
                                                 const GLint *firsts,
                                                 const GLsizei *counts,
                                                 const GLsizei *instanceCounts,
                                                 GLsizei drawcount,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_counts(const State &glState,
                                                 bool isCallValid,
                                                 PrimitiveMode modePacked,
                                                 const GLint *firsts,
                                                 const GLsizei *counts,
                                                 const GLsizei *instanceCounts,
                                                 GLsizei drawcount,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_instanceCounts(const State &glState,
                                                         bool isCallValid,
                                                         PrimitiveMode modePacked,
                                                         const GLint *firsts,
                                                         const GLsizei *counts,
                                                         const GLsizei *instanceCounts,
                                                         GLsizei drawcount,
                                                         angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsANGLE_counts(const State &glState,
                                          bool isCallValid,
                                          PrimitiveMode modePacked,
                                          const GLsizei *counts,
                                          DrawElementsType typePacked,
                                          const GLvoid *const *indices,
                                          GLsizei drawcount,
                                          angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsANGLE_indices(const State &glState,
                                           bool isCallValid,
                                           PrimitiveMode modePacked,
                                           const GLsizei *counts,
                                           DrawElementsType typePacked,
                                           const GLvoid *const *indices,
                                           GLsizei drawcount,
                                           angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedANGLE_counts(const State &glState,
                                                   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 State &glState,
                                                    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 State &glState,
                                                           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 State &glState,
                                       bool isCallValid,
                                       const GLchar *name,
                                       angle::ParamCapture *paramCapture);
void CaptureDisableExtensionANGLE_name(const State &glState,
                                       bool isCallValid,
                                       const GLchar *name,
                                       angle::ParamCapture *paramCapture);
void CaptureGetBooleanvRobustANGLE_length(const State &glState,
                                          bool isCallValid,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLboolean *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetBooleanvRobustANGLE_params(const State &glState,
                                          bool isCallValid,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLboolean *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetBufferParameterivRobustANGLE_length(const State &glState,
                                                   bool isCallValid,
                                                   BufferBinding targetPacked,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint *params,
                                                   angle::ParamCapture *paramCapture);
void CaptureGetBufferParameterivRobustANGLE_params(const State &glState,
                                                   bool isCallValid,
                                                   BufferBinding targetPacked,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint *params,
                                                   angle::ParamCapture *paramCapture);
void CaptureGetFloatvRobustANGLE_length(const State &glState,
                                        bool isCallValid,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLfloat *params,
                                        angle::ParamCapture *paramCapture);
void CaptureGetFloatvRobustANGLE_params(const State &glState,
                                        bool isCallValid,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLfloat *params,
                                        angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
    const State &glState,
    bool isCallValid,
    GLenum target,
    GLenum attachment,
    GLenum pname,
    GLsizei bufSize,
    GLsizei *length,
    GLint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
    const State &glState,
    bool isCallValid,
    GLenum target,
    GLenum attachment,
    GLenum pname,
    GLsizei bufSize,
    GLsizei *length,
    GLint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetIntegervRobustANGLE_length(const State &glState,
                                          bool isCallValid,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *data,
                                          angle::ParamCapture *paramCapture);
void CaptureGetIntegervRobustANGLE_data(const State &glState,
                                        bool isCallValid,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLint *data,
                                        angle::ParamCapture *paramCapture);
void CaptureGetProgramivRobustANGLE_length(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetProgramivRobustANGLE_params(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivRobustANGLE_length(const State &glState,
                                                         bool isCallValid,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLint *params,
                                                         angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivRobustANGLE_params(const State &glState,
                                                         bool isCallValid,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLint *params,
                                                         angle::ParamCapture *paramCapture);
void CaptureGetShaderivRobustANGLE_length(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID shaderPacked,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetShaderivRobustANGLE_params(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID shaderPacked,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetTexParameterfvRobustANGLE_length(const State &glState,
                                                bool isCallValid,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterfvRobustANGLE_params(const State &glState,
                                                bool isCallValid,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterivRobustANGLE_length(const State &glState,
                                                bool isCallValid,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterivRobustANGLE_params(const State &glState,
                                                bool isCallValid,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetUniformfvRobustANGLE_length(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLfloat *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformfvRobustANGLE_params(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLfloat *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformivRobustANGLE_length(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformivRobustANGLE_params(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribfvRobustANGLE_length(const State &glState,
                                                bool isCallValid,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribfvRobustANGLE_params(const State &glState,
                                                bool isCallValid,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribivRobustANGLE_length(const State &glState,
                                                bool isCallValid,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribivRobustANGLE_params(const State &glState,
                                                bool isCallValid,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribPointervRobustANGLE_length(const State &glState,
                                                      bool isCallValid,
                                                      GLuint index,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      void **pointer,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribPointervRobustANGLE_pointer(const State &glState,
                                                       bool isCallValid,
                                                       GLuint index,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       void **pointer,
                                                       angle::ParamCapture *paramCapture);
void CaptureReadPixelsRobustANGLE_length(const State &glState,
                                         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 State &glState,
                                          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 State &glState,
                                       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 State &glState,
                                         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 State &glState,
                                         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 State &glState,
                                             bool isCallValid,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             const GLfloat *params,
                                             angle::ParamCapture *paramCapture);
void CaptureTexParameterivRobustANGLE_params(const State &glState,
                                             bool isCallValid,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             const GLint *params,
                                             angle::ParamCapture *paramCapture);
void CaptureTexSubImage2DRobustANGLE_pixels(const State &glState,
                                            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 State &glState,
                                         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 State &glState,
                                            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 State &glState,
                                                 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 State &glState,
                                                    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 State &glState,
                                                 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 State &glState,
                                                    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 State &glState,
                                         bool isCallValid,
                                         QueryType targetPacked,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryivRobustANGLE_params(const State &glState,
                                         bool isCallValid,
                                         QueryType targetPacked,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivRobustANGLE_length(const State &glState,
                                                bool isCallValid,
                                                QueryID idPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLuint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivRobustANGLE_params(const State &glState,
                                                bool isCallValid,
                                                QueryID idPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLuint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervRobustANGLE_length(const State &glState,
                                                bool isCallValid,
                                                BufferBinding targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                void **params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervRobustANGLE_params(const State &glState,
                                                bool isCallValid,
                                                BufferBinding targetPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                void **params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetIntegeri_vRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            GLenum target,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *data,
                                            angle::ParamCapture *paramCapture);
void CaptureGetIntegeri_vRobustANGLE_data(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLuint index,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *data,
                                          angle::ParamCapture *paramCapture);
void CaptureGetInternalformativRobustANGLE_length(const State &glState,
                                                  bool isCallValid,
                                                  GLenum target,
                                                  GLenum internalformat,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetInternalformativRobustANGLE_params(const State &glState,
                                                  bool isCallValid,
                                                  GLenum target,
                                                  GLenum internalformat,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIivRobustANGLE_length(const State &glState,
                                                 bool isCallValid,
                                                 GLuint index,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIivRobustANGLE_params(const State &glState,
                                                 bool isCallValid,
                                                 GLuint index,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIuivRobustANGLE_length(const State &glState,
                                                  bool isCallValid,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIuivRobustANGLE_params(const State &glState,
                                                  bool isCallValid,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetUniformuivRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLuint *params,
                                            angle::ParamCapture *paramCapture);
void CaptureGetUniformuivRobustANGLE_params(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLuint *params,
                                            angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockivRobustANGLE_length(const State &glState,
                                                      bool isCallValid,
                                                      ShaderProgramID programPacked,
                                                      GLuint uniformBlockIndex,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLint *params,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockivRobustANGLE_params(const State &glState,
                                                      bool isCallValid,
                                                      ShaderProgramID programPacked,
                                                      GLuint uniformBlockIndex,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLint *params,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetInteger64vRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint64 *data,
                                            angle::ParamCapture *paramCapture);
void CaptureGetInteger64vRobustANGLE_data(const State &glState,
                                          bool isCallValid,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint64 *data,
                                          angle::ParamCapture *paramCapture);
void CaptureGetInteger64i_vRobustANGLE_length(const State &glState,
                                              bool isCallValid,
                                              GLenum target,
                                              GLuint index,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLint64 *data,
                                              angle::ParamCapture *paramCapture);
void CaptureGetInteger64i_vRobustANGLE_data(const State &glState,
                                            bool isCallValid,
                                            GLenum target,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint64 *data,
                                            angle::ParamCapture *paramCapture);
void CaptureGetBufferParameteri64vRobustANGLE_length(const State &glState,
                                                     bool isCallValid,
                                                     BufferBinding targetPacked,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint64 *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetBufferParameteri64vRobustANGLE_params(const State &glState,
                                                     bool isCallValid,
                                                     BufferBinding targetPacked,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint64 *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureSamplerParameterivRobustANGLE_param(const State &glState,
                                                bool isCallValid,
                                                SamplerID samplerPacked,
                                                GLuint pname,
                                                GLsizei bufSize,
                                                const GLint *param,
                                                angle::ParamCapture *paramCapture);
void CaptureSamplerParameterfvRobustANGLE_param(const State &glState,
                                                bool isCallValid,
                                                SamplerID samplerPacked,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                const GLfloat *param,
                                                angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterivRobustANGLE_length(const State &glState,
                                                    bool isCallValid,
                                                    SamplerID samplerPacked,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterivRobustANGLE_params(const State &glState,
                                                    bool isCallValid,
                                                    SamplerID samplerPacked,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterfvRobustANGLE_length(const State &glState,
                                                    bool isCallValid,
                                                    SamplerID samplerPacked,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLfloat *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterfvRobustANGLE_params(const State &glState,
                                                    bool isCallValid,
                                                    SamplerID samplerPacked,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLfloat *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferParameterivRobustANGLE_length(const State &glState,
                                                        bool isCallValid,
                                                        GLenum target,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *params,
                                                        angle::ParamCapture *paramCapture);
void CaptureGetFramebufferParameterivRobustANGLE_params(const State &glState,
                                                        bool isCallValid,
                                                        GLenum target,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *params,
                                                        angle::ParamCapture *paramCapture);
void CaptureGetProgramInterfaceivRobustANGLE_length(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    GLenum programInterface,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetProgramInterfaceivRobustANGLE_params(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    GLenum programInterface,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetBooleani_vRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            GLenum target,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLboolean *data,
                                            angle::ParamCapture *paramCapture);
void CaptureGetBooleani_vRobustANGLE_data(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLuint index,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLboolean *data,
                                          angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvRobustANGLE_length(const State &glState,
                                               bool isCallValid,
                                               GLenum pname,
                                               GLuint index,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLfloat *val,
                                               angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvRobustANGLE_val(const State &glState,
                                            bool isCallValid,
                                            GLenum pname,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *val,
                                            angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivRobustANGLE_length(const State &glState,
                                                     bool isCallValid,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivRobustANGLE_params(const State &glState,
                                                     bool isCallValid,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvRobustANGLE_length(const State &glState,
                                                     bool isCallValid,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLfloat *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvRobustANGLE_params(const State &glState,
                                                     bool isCallValid,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLfloat *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetPointervRobustANGLERobustANGLE_length(const State &glState,
                                                     bool isCallValid,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     void **params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetPointervRobustANGLERobustANGLE_params(const State &glState,
                                                     bool isCallValid,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     void **params,
                                                     angle::ParamCapture *paramCapture);
void CaptureReadnPixelsRobustANGLE_length(const State &glState,
                                          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 State &glState,
                                           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 State &glState,
                                        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 State &glState,
                                        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 State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params,
                                            angle::ParamCapture *paramCapture);
void CaptureGetnUniformfvRobustANGLE_params(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params,
                                            angle::ParamCapture *paramCapture);
void CaptureGetnUniformivRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params,
                                            angle::ParamCapture *paramCapture);
void CaptureGetnUniformivRobustANGLE_params(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params,
                                            angle::ParamCapture *paramCapture);
void CaptureGetnUniformuivRobustANGLE_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params,
                                             angle::ParamCapture *paramCapture);
void CaptureGetnUniformuivRobustANGLE_params(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params,
                                             angle::ParamCapture *paramCapture);
void CaptureTexParameterIivRobustANGLE_params(const State &glState,
                                              bool isCallValid,
                                              TextureType targetPacked,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              const GLint *params,
                                              angle::ParamCapture *paramCapture);
void CaptureTexParameterIuivRobustANGLE_params(const State &glState,
                                               bool isCallValid,
                                               TextureType targetPacked,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               const GLuint *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIivRobustANGLE_length(const State &glState,
                                                 bool isCallValid,
                                                 TextureType targetPacked,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIivRobustANGLE_params(const State &glState,
                                                 bool isCallValid,
                                                 TextureType targetPacked,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIuivRobustANGLE_length(const State &glState,
                                                  bool isCallValid,
                                                  TextureType targetPacked,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIuivRobustANGLE_params(const State &glState,
                                                  bool isCallValid,
                                                  TextureType targetPacked,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIivRobustANGLE_param(const State &glState,
                                                 bool isCallValid,
                                                 SamplerID samplerPacked,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 const GLint *param,
                                                 angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIuivRobustANGLE_param(const State &glState,
                                                  bool isCallValid,
                                                  SamplerID samplerPacked,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  const GLuint *param,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIivRobustANGLE_length(const State &glState,
                                                     bool isCallValid,
                                                     SamplerID samplerPacked,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIivRobustANGLE_params(const State &glState,
                                                     bool isCallValid,
                                                     SamplerID samplerPacked,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIuivRobustANGLE_length(const State &glState,
                                                      bool isCallValid,
                                                      SamplerID samplerPacked,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLuint *params,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIuivRobustANGLE_params(const State &glState,
                                                      bool isCallValid,
                                                      SamplerID samplerPacked,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLuint *params,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivRobustANGLE_length(const State &glState,
                                               bool isCallValid,
                                               QueryID idPacked,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLint *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivRobustANGLE_params(const State &glState,
                                               bool isCallValid,
                                               QueryID idPacked,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLint *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vRobustANGLE_length(const State &glState,
                                                 bool isCallValid,
                                                 QueryID idPacked,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint64 *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vRobustANGLE_params(const State &glState,
                                                 bool isCallValid,
                                                 QueryID idPacked,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint64 *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vRobustANGLE_length(const State &glState,
                                                  bool isCallValid,
                                                  QueryID idPacked,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint64 *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vRobustANGLE_params(const State &glState,
                                                  bool isCallValid,
                                                  QueryID idPacked,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint64 *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvANGLE_val(const State &glState,
                                      bool isCallValid,
                                      GLenum pname,
                                      GLuint index,
                                      GLfloat *val,
                                      angle::ParamCapture *paramCapture);
void CaptureGetTranslatedShaderSourceANGLE_length(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID shaderPacked,
                                                  GLsizei bufsize,
                                                  GLsizei *length,
                                                  GLchar *source,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetTranslatedShaderSourceANGLE_source(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID shaderPacked,
                                                  GLsizei bufsize,
                                                  GLsizei *length,
                                                  GLchar *source,
                                                  angle::ParamCapture *paramCapture);
void CaptureBindUniformLocationCHROMIUM_name(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             const GLchar *name,
                                             angle::ParamCapture *paramCapture);
void CaptureBindFragDataLocationEXT_name(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
                                         GLuint color,
                                         const GLchar *name,
                                         angle::ParamCapture *paramCapture);
void CaptureBindFragDataLocationIndexedEXT_name(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                GLuint colorNumber,
                                                GLuint index,
                                                const GLchar *name,
                                                angle::ParamCapture *paramCapture);
void CaptureGetFragDataIndexEXT_name(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     const GLchar *name,
                                     angle::ParamCapture *paramCapture);
void CaptureGetProgramResourceLocationIndexEXT_name(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    GLenum programInterface,
                                                    const GLchar *name,
                                                    angle::ParamCapture *paramCapture);
void CaptureBufferStorageEXT_data(const State &glState,
                                  bool isCallValid,
                                  BufferBinding targetPacked,
                                  GLsizeiptr size,
                                  const void *data,
                                  GLbitfield flags,
                                  angle::ParamCapture *paramCapture);
void CaptureInsertEventMarkerEXT_marker(const State &glState,
                                        bool isCallValid,
                                        GLsizei length,
                                        const GLchar *marker,
                                        angle::ParamCapture *paramCapture);
void CapturePushGroupMarkerEXT_marker(const State &glState,
                                      bool isCallValid,
                                      GLsizei length,
                                      const GLchar *marker,
                                      angle::ParamCapture *paramCapture);
void CaptureDiscardFramebufferEXT_attachments(const State &glState,
                                              bool isCallValid,
                                              GLenum target,
                                              GLsizei numAttachments,
                                              const GLenum *attachments,
                                              angle::ParamCapture *paramCapture);
void CaptureDeleteQueriesEXT_idsPacked(const State &glState,
                                       bool isCallValid,
                                       GLsizei n,
                                       const QueryID *idsPacked,
                                       angle::ParamCapture *paramCapture);
void CaptureGenQueriesEXT_idsPacked(const State &glState,
                                    bool isCallValid,
                                    GLsizei n,
                                    QueryID *idsPacked,
                                    angle::ParamCapture *paramCapture);
void CaptureGetInteger64vEXT_data(const State &glState,
                                  bool isCallValid,
                                  GLenum pname,
                                  GLint64 *data,
                                  angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vEXT_params(const State &glState,
                                         bool isCallValid,
                                         QueryID idPacked,
                                         GLenum pname,
                                         GLint64 *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivEXT_params(const State &glState,
                                       bool isCallValid,
                                       QueryID idPacked,
                                       GLenum pname,
                                       GLint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vEXT_params(const State &glState,
                                          bool isCallValid,
                                          QueryID idPacked,
                                          GLenum pname,
                                          GLuint64 *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivEXT_params(const State &glState,
                                        bool isCallValid,
                                        QueryID idPacked,
                                        GLenum pname,
                                        GLuint *params,
                                        angle::ParamCapture *paramCapture);
void CaptureGetQueryivEXT_params(const State &glState,
                                 bool isCallValid,
                                 QueryType targetPacked,
                                 GLenum pname,
                                 GLint *params,
                                 angle::ParamCapture *paramCapture);
void CaptureDrawBuffersEXT_bufs(const State &glState,
                                bool isCallValid,
                                GLsizei n,
                                const GLenum *bufs,
                                angle::ParamCapture *paramCapture);
void CaptureDrawElementsBaseVertexEXT_indices(const State &glState,
                                              bool isCallValid,
                                              PrimitiveMode modePacked,
                                              GLsizei count,
                                              DrawElementsType typePacked,
                                              const void *indices,
                                              GLint basevertex,
                                              angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedBaseVertexEXT_indices(const State &glState,
                                                       bool isCallValid,
                                                       PrimitiveMode modePacked,
                                                       GLsizei count,
                                                       DrawElementsType typePacked,
                                                       const void *indices,
                                                       GLsizei instancecount,
                                                       GLint basevertex,
                                                       angle::ParamCapture *paramCapture);
void CaptureDrawRangeElementsBaseVertexEXT_indices(const State &glState,
                                                   bool isCallValid,
                                                   PrimitiveMode modePacked,
                                                   GLuint start,
                                                   GLuint end,
                                                   GLsizei count,
                                                   DrawElementsType typePacked,
                                                   const void *indices,
                                                   GLint basevertex,
                                                   angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsBaseVertexEXT_count(const State &glState,
                                                 bool isCallValid,
                                                 PrimitiveMode modePacked,
                                                 const GLsizei *count,
                                                 DrawElementsType typePacked,
                                                 const void *const *indices,
                                                 GLsizei primcount,
                                                 const GLint *basevertex,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsBaseVertexEXT_indices(const State &glState,
                                                   bool isCallValid,
                                                   PrimitiveMode modePacked,
                                                   const GLsizei *count,
                                                   DrawElementsType typePacked,
                                                   const void *const *indices,
                                                   GLsizei primcount,
                                                   const GLint *basevertex,
                                                   angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsBaseVertexEXT_basevertex(const State &glState,
                                                      bool isCallValid,
                                                      PrimitiveMode modePacked,
                                                      const GLsizei *count,
                                                      DrawElementsType typePacked,
                                                      const void *const *indices,
                                                      GLsizei primcount,
                                                      const GLint *basevertex,
                                                      angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedEXT_indices(const State &glState,
                                             bool isCallValid,
                                             PrimitiveMode modePacked,
                                             GLsizei count,
                                             DrawElementsType typePacked,
                                             const void *indices,
                                             GLsizei primcount,
                                             angle::ParamCapture *paramCapture);
void CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(const State &glState,
                                                       bool isCallValid,
                                                       GLsizei n,
                                                       MemoryObjectID *memoryObjectsPacked,
                                                       angle::ParamCapture *paramCapture);
void CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(const State &glState,
                                                       bool isCallValid,
                                                       GLsizei n,
                                                       const MemoryObjectID *memoryObjectsPacked,
                                                       angle::ParamCapture *paramCapture);
void CaptureGetMemoryObjectParameterivEXT_params(const State &glState,
                                                 bool isCallValid,
                                                 MemoryObjectID memoryObjectPacked,
                                                 GLenum pname,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetUnsignedBytevEXT_data(const State &glState,
                                     bool isCallValid,
                                     GLenum pname,
                                     GLubyte *data,
                                     angle::ParamCapture *paramCapture);
void CaptureGetUnsignedBytei_vEXT_data(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLuint index,
                                       GLubyte *data,
                                       angle::ParamCapture *paramCapture);
void CaptureMemoryObjectParameterivEXT_params(const State &glState,
                                              bool isCallValid,
                                              MemoryObjectID memoryObjectPacked,
                                              GLenum pname,
                                              const GLint *params,
                                              angle::ParamCapture *paramCapture);
void CaptureGetnUniformfvEXT_params(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei bufSize,
                                    GLfloat *params,
                                    angle::ParamCapture *paramCapture);
void CaptureGetnUniformivEXT_params(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei bufSize,
                                    GLint *params,
                                    angle::ParamCapture *paramCapture);
void CaptureReadnPixelsEXT_data(const State &glState,
                                bool isCallValid,
                                GLint x,
                                GLint y,
                                GLsizei width,
                                GLsizei height,
                                GLenum format,
                                GLenum type,
                                GLsizei bufSize,
                                void *data,
                                angle::ParamCapture *paramCapture);
void CaptureDeleteSemaphoresEXT_semaphoresPacked(const State &glState,
                                                 bool isCallValid,
                                                 GLsizei n,
                                                 const SemaphoreID *semaphoresPacked,
                                                 angle::ParamCapture *paramCapture);
void CaptureGenSemaphoresEXT_semaphoresPacked(const State &glState,
                                              bool isCallValid,
                                              GLsizei n,
                                              SemaphoreID *semaphoresPacked,
                                              angle::ParamCapture *paramCapture);
void CaptureGetSemaphoreParameterui64vEXT_params(const State &glState,
                                                 bool isCallValid,
                                                 SemaphoreID semaphorePacked,
                                                 GLenum pname,
                                                 GLuint64 *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureSemaphoreParameterui64vEXT_params(const State &glState,
                                              bool isCallValid,
                                              SemaphoreID semaphorePacked,
                                              GLenum pname,
                                              const GLuint64 *params,
                                              angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_buffersPacked(const State &glState,
                                             bool isCallValid,
                                             SemaphoreID semaphorePacked,
                                             GLuint numBufferBarriers,
                                             const BufferID *buffersPacked,
                                             GLuint numTextureBarriers,
                                             const TextureID *texturesPacked,
                                             const GLenum *dstLayouts,
                                             angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_texturesPacked(const State &glState,
                                              bool isCallValid,
                                              SemaphoreID semaphorePacked,
                                              GLuint numBufferBarriers,
                                              const BufferID *buffersPacked,
                                              GLuint numTextureBarriers,
                                              const TextureID *texturesPacked,
                                              const GLenum *dstLayouts,
                                              angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_dstLayouts(const State &glState,
                                          bool isCallValid,
                                          SemaphoreID semaphorePacked,
                                          GLuint numBufferBarriers,
                                          const BufferID *buffersPacked,
                                          GLuint numTextureBarriers,
                                          const TextureID *texturesPacked,
                                          const GLenum *dstLayouts,
                                          angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_buffersPacked(const State &glState,
                                           bool isCallValid,
                                           SemaphoreID semaphorePacked,
                                           GLuint numBufferBarriers,
                                           const BufferID *buffersPacked,
                                           GLuint numTextureBarriers,
                                           const TextureID *texturesPacked,
                                           const GLenum *srcLayouts,
                                           angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_texturesPacked(const State &glState,
                                            bool isCallValid,
                                            SemaphoreID semaphorePacked,
                                            GLuint numBufferBarriers,
                                            const BufferID *buffersPacked,
                                            GLuint numTextureBarriers,
                                            const TextureID *texturesPacked,
                                            const GLenum *srcLayouts,
                                            angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_srcLayouts(const State &glState,
                                        bool isCallValid,
                                        SemaphoreID semaphorePacked,
                                        GLuint numBufferBarriers,
                                        const BufferID *buffersPacked,
                                        GLuint numTextureBarriers,
                                        const TextureID *texturesPacked,
                                        const GLenum *srcLayouts,
                                        angle::ParamCapture *paramCapture);
void CaptureDebugMessageCallbackKHR_userParam(const State &glState,
                                              bool isCallValid,
                                              GLDEBUGPROCKHR callback,
                                              const void *userParam,
                                              angle::ParamCapture *paramCapture);
void CaptureDebugMessageControlKHR_ids(const State &glState,
                                       bool isCallValid,
                                       GLenum source,
                                       GLenum type,
                                       GLenum severity,
                                       GLsizei count,
                                       const GLuint *ids,
                                       GLboolean enabled,
                                       angle::ParamCapture *paramCapture);
void CaptureDebugMessageInsertKHR_buf(const State &glState,
                                      bool isCallValid,
                                      GLenum source,
                                      GLenum type,
                                      GLuint id,
                                      GLenum severity,
                                      GLsizei length,
                                      const GLchar *buf,
                                      angle::ParamCapture *paramCapture);
void CaptureGetDebugMessageLogKHR_sources(const State &glState,
                                          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 State &glState,
                                        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 State &glState,
                                      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 State &glState,
                                             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 State &glState,
                                          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 State &glState,
                                             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 State &glState,
                                     bool isCallValid,
                                     GLenum identifier,
                                     GLuint name,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *label,
                                     angle::ParamCapture *paramCapture);
void CaptureGetObjectLabelKHR_label(const State &glState,
                                    bool isCallValid,
                                    GLenum identifier,
                                    GLuint name,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLchar *label,
                                    angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_ptr(const State &glState,
                                     bool isCallValid,
                                     const void *ptr,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *label,
                                     angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_length(const State &glState,
                                        bool isCallValid,
                                        const void *ptr,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLchar *label,
                                        angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_label(const State &glState,
                                       bool isCallValid,
                                       const void *ptr,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLchar *label,
                                       angle::ParamCapture *paramCapture);
void CaptureGetPointervKHR_params(const State &glState,
                                  bool isCallValid,
                                  GLenum pname,
                                  void **params,
                                  angle::ParamCapture *paramCapture);
void CaptureObjectLabelKHR_label(const State &glState,
                                 bool isCallValid,
                                 GLenum identifier,
                                 GLuint name,
                                 GLsizei length,
                                 const GLchar *label,
                                 angle::ParamCapture *paramCapture);
void CaptureObjectPtrLabelKHR_ptr(const State &glState,
                                  bool isCallValid,
                                  const void *ptr,
                                  GLsizei length,
                                  const GLchar *label,
                                  angle::ParamCapture *paramCapture);
void CaptureObjectPtrLabelKHR_label(const State &glState,
                                    bool isCallValid,
                                    const void *ptr,
                                    GLsizei length,
                                    const GLchar *label,
                                    angle::ParamCapture *paramCapture);
void CapturePushDebugGroupKHR_message(const State &glState,
                                      bool isCallValid,
                                      GLenum source,
                                      GLuint id,
                                      GLsizei length,
                                      const GLchar *message,
                                      angle::ParamCapture *paramCapture);
void CaptureDeleteFencesNV_fencesPacked(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        const FenceNVID *fencesPacked,
                                        angle::ParamCapture *paramCapture);
void CaptureGenFencesNV_fencesPacked(const State &glState,
                                     bool isCallValid,
                                     GLsizei n,
                                     FenceNVID *fencesPacked,
                                     angle::ParamCapture *paramCapture);
void CaptureGetFenceivNV_params(const State &glState,
                                bool isCallValid,
                                FenceNVID fencePacked,
                                GLenum pname,
                                GLint *params,
                                angle::ParamCapture *paramCapture);
void CaptureDrawElementsBaseVertexOES_indices(const State &glState,
                                              bool isCallValid,
                                              PrimitiveMode modePacked,
                                              GLsizei count,
                                              DrawElementsType typePacked,
                                              const void *indices,
                                              GLint basevertex,
                                              angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedBaseVertexOES_indices(const State &glState,
                                                       bool isCallValid,
                                                       PrimitiveMode modePacked,
                                                       GLsizei count,
                                                       DrawElementsType typePacked,
                                                       const void *indices,
                                                       GLsizei instancecount,
                                                       GLint basevertex,
                                                       angle::ParamCapture *paramCapture);
void CaptureDrawRangeElementsBaseVertexOES_indices(const State &glState,
                                                   bool isCallValid,
                                                   PrimitiveMode modePacked,
                                                   GLuint start,
                                                   GLuint end,
                                                   GLsizei count,
                                                   DrawElementsType typePacked,
                                                   const void *indices,
                                                   GLint basevertex,
                                                   angle::ParamCapture *paramCapture);
void CaptureDrawTexfvOES_coords(const State &glState,
                                bool isCallValid,
                                const GLfloat *coords,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexivOES_coords(const State &glState,
                                bool isCallValid,
                                const GLint *coords,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexsvOES_coords(const State &glState,
                                bool isCallValid,
                                const GLshort *coords,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexxvOES_coords(const State &glState,
                                bool isCallValid,
                                const GLfixed *coords,
                                angle::ParamCapture *paramCapture);
void CaptureDeleteFramebuffersOES_framebuffersPacked(const State &glState,
                                                     bool isCallValid,
                                                     GLsizei n,
                                                     const FramebufferID *framebuffersPacked,
                                                     angle::ParamCapture *paramCapture);
void CaptureDeleteRenderbuffersOES_renderbuffersPacked(const State &glState,
                                                       bool isCallValid,
                                                       GLsizei n,
                                                       const RenderbufferID *renderbuffersPacked,
                                                       angle::ParamCapture *paramCapture);
void CaptureGenFramebuffersOES_framebuffersPacked(const State &glState,
                                                  bool isCallValid,
                                                  GLsizei n,
                                                  FramebufferID *framebuffersPacked,
                                                  angle::ParamCapture *paramCapture);
void CaptureGenRenderbuffersOES_renderbuffersPacked(const State &glState,
                                                    bool isCallValid,
                                                    GLsizei n,
                                                    RenderbufferID *renderbuffersPacked,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivOES_params(const State &glState,
                                                          bool isCallValid,
                                                          GLenum target,
                                                          GLenum attachment,
                                                          GLenum pname,
                                                          GLint *params,
                                                          angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivOES_params(const State &glState,
                                                 bool isCallValid,
                                                 GLenum target,
                                                 GLenum pname,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_length(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLenum *binaryFormat,
                                       void *binary,
                                       angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_binaryFormat(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLenum *binaryFormat,
                                             void *binary,
                                             angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_binary(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLenum *binaryFormat,
                                       void *binary,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramBinaryOES_binary(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    GLenum binaryFormat,
                                    const void *binary,
                                    GLint length,
                                    angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervOES_params(const State &glState,
                                        bool isCallValid,
                                        BufferBinding targetPacked,
                                        GLenum pname,
                                        void **params,
                                        angle::ParamCapture *paramCapture);
void CaptureMatrixIndexPointerOES_pointer(const State &glState,
                                          bool isCallValid,
                                          GLint size,
                                          GLenum type,
                                          GLsizei stride,
                                          const void *pointer,
                                          angle::ParamCapture *paramCapture);
void CaptureWeightPointerOES_pointer(const State &glState,
                                     bool isCallValid,
                                     GLint size,
                                     GLenum type,
                                     GLsizei stride,
                                     const void *pointer,
                                     angle::ParamCapture *paramCapture);
void CapturePointSizePointerOES_pointer(const State &glState,
                                        bool isCallValid,
                                        VertexAttribType typePacked,
                                        GLsizei stride,
                                        const void *pointer,
                                        angle::ParamCapture *paramCapture);
void CaptureQueryMatrixxOES_mantissa(const State &glState,
                                     bool isCallValid,
                                     GLfixed *mantissa,
                                     GLint *exponent,
                                     angle::ParamCapture *paramCapture);
void CaptureQueryMatrixxOES_exponent(const State &glState,
                                     bool isCallValid,
                                     GLfixed *mantissa,
                                     GLint *exponent,
                                     angle::ParamCapture *paramCapture);
void CaptureCompressedTexImage3DOES_data(const State &glState,
                                         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 State &glState,
                                            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 State &glState,
                                 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 State &glState,
                                    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 State &glState,
                                             bool isCallValid,
                                             SamplerID samplerPacked,
                                             GLenum pname,
                                             GLint *params,
                                             angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIuivOES_params(const State &glState,
                                              bool isCallValid,
                                              SamplerID samplerPacked,
                                              GLenum pname,
                                              GLuint *params,
                                              angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIivOES_params(const State &glState,
                                         bool isCallValid,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIuivOES_params(const State &glState,
                                          bool isCallValid,
                                          TextureType targetPacked,
                                          GLenum pname,
                                          GLuint *params,
                                          angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIivOES_param(const State &glState,
                                         bool isCallValid,
                                         SamplerID samplerPacked,
                                         GLenum pname,
                                         const GLint *param,
                                         angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIuivOES_param(const State &glState,
                                          bool isCallValid,
                                          SamplerID samplerPacked,
                                          GLenum pname,
                                          const GLuint *param,
                                          angle::ParamCapture *paramCapture);
void CaptureTexParameterIivOES_params(const State &glState,
                                      bool isCallValid,
                                      TextureType targetPacked,
                                      GLenum pname,
                                      const GLint *params,
                                      angle::ParamCapture *paramCapture);
void CaptureTexParameterIuivOES_params(const State &glState,
                                       bool isCallValid,
                                       TextureType targetPacked,
                                       GLenum pname,
                                       const GLuint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureGetTexGenfvOES_params(const State &glState,
                                  bool isCallValid,
                                  GLenum coord,
                                  GLenum pname,
                                  GLfloat *params,
                                  angle::ParamCapture *paramCapture);
void CaptureGetTexGenivOES_params(const State &glState,
                                  bool isCallValid,
                                  GLenum coord,
                                  GLenum pname,
                                  GLint *params,
                                  angle::ParamCapture *paramCapture);
void CaptureGetTexGenxvOES_params(const State &glState,
                                  bool isCallValid,
                                  GLenum coord,
                                  GLenum pname,
                                  GLfixed *params,
                                  angle::ParamCapture *paramCapture);
void CaptureTexGenfvOES_params(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               const GLfloat *params,
                               angle::ParamCapture *paramCapture);
void CaptureTexGenivOES_params(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               const GLint *params,
                               angle::ParamCapture *paramCapture);
void CaptureTexGenxvOES_params(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               const GLfixed *params,
                               angle::ParamCapture *paramCapture);
void CaptureDeleteVertexArraysOES_arraysPacked(const State &glState,
                                               bool isCallValid,
                                               GLsizei n,
                                               const VertexArrayID *arraysPacked,
                                               angle::ParamCapture *paramCapture);
void CaptureGenVertexArraysOES_arraysPacked(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            VertexArrayID *arraysPacked,
                                            angle::ParamCapture *paramCapture);
}  // namespace gl

#endif  // LIBANGLE_CAPTURE_GLES_ext_AUTOGEN_H_