// 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/capture/FrameCapture.h"
#ifdef ANGLE_ENABLE_CL
#    include "common/PackedCLEnums_autogen.h"
#endif

namespace gl
{

// Method Captures

// GL_AMD_performance_monitor
angle::CallCapture CaptureBeginPerfMonitorAMD(const State &glState,
                                              bool isCallValid,
                                              GLuint monitor);
angle::CallCapture CaptureDeletePerfMonitorsAMD(const State &glState,
                                                bool isCallValid,
                                                GLsizei n,
                                                GLuint *monitors);
angle::CallCapture CaptureEndPerfMonitorAMD(const State &glState, bool isCallValid, GLuint monitor);
angle::CallCapture CaptureGenPerfMonitorsAMD(const State &glState,
                                             bool isCallValid,
                                             GLsizei n,
                                             GLuint *monitors);
angle::CallCapture CaptureGetPerfMonitorCounterDataAMD(const State &glState,
                                                       bool isCallValid,
                                                       GLuint monitor,
                                                       GLenum pname,
                                                       GLsizei dataSize,
                                                       GLuint *data,
                                                       GLint *bytesWritten);
angle::CallCapture CaptureGetPerfMonitorCounterInfoAMD(const State &glState,
                                                       bool isCallValid,
                                                       GLuint group,
                                                       GLuint counter,
                                                       GLenum pname,
                                                       void *data);
angle::CallCapture CaptureGetPerfMonitorCounterStringAMD(const State &glState,
                                                         bool isCallValid,
                                                         GLuint group,
                                                         GLuint counter,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLchar *counterString);
angle::CallCapture CaptureGetPerfMonitorCountersAMD(const State &glState,
                                                    bool isCallValid,
                                                    GLuint group,
                                                    GLint *numCounters,
                                                    GLint *maxActiveCounters,
                                                    GLsizei counterSize,
                                                    GLuint *counters);
angle::CallCapture CaptureGetPerfMonitorGroupStringAMD(const State &glState,
                                                       bool isCallValid,
                                                       GLuint group,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLchar *groupString);
angle::CallCapture CaptureGetPerfMonitorGroupsAMD(const State &glState,
                                                  bool isCallValid,
                                                  GLint *numGroups,
                                                  GLsizei groupsSize,
                                                  GLuint *groups);
angle::CallCapture CaptureSelectPerfMonitorCountersAMD(const State &glState,
                                                       bool isCallValid,
                                                       GLuint monitor,
                                                       GLboolean enable,
                                                       GLuint group,
                                                       GLint numCounters,
                                                       GLuint *counterList);

// GL_ANDROID_extension_pack_es31a

// 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 void *indices,
    GLsizei instanceCount,
    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 void *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount);

// GL_ANGLE_blob_cache
angle::CallCapture CaptureBlobCacheCallbacksANGLE(const State &glState,
                                                  bool isCallValid,
                                                  GLSETBLOBPROCANGLE set,
                                                  GLGETBLOBPROCANGLE get,
                                                  const void *userParam);
angle::CallCapture CaptureGetPointervANGLE(const State &glState,
                                           bool isCallValid,
                                           GLenum pname,
                                           void **params);

// GL_ANGLE_client_arrays

// GL_ANGLE_clip_cull_distance

// 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_depth_texture

// 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 CaptureGetCompressedTexImageANGLE(const State &glState,
                                                     bool isCallValid,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     void *pixels);
angle::CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
                                                    bool isCallValid,
                                                    GLenum target,
                                                    GLenum format,
                                                    GLenum type,
                                                    void *pixels);

// GL_ANGLE_get_serialized_context_string

// GL_ANGLE_get_tex_level_parameter
angle::CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState,
                                                      bool isCallValid,
                                                      TextureTarget targetPacked,
                                                      GLint level,
                                                      TextureImageParameter pnamePacked,
                                                      GLint *params);
angle::CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState,
                                                      bool isCallValid,
                                                      TextureTarget targetPacked,
                                                      GLint level,
                                                      TextureImageParameter pnamePacked,
                                                      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_logic_op
angle::CallCapture CaptureLogicOpANGLE(const State &glState,
                                       bool isCallValid,
                                       LogicalOperation opcodePacked);

// 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,
                                                    const void *imageCreateInfoPNext);
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,
                                                               const void *imageCreateInfoPNext);
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,
                                                    const void *imageCreateInfoPNext);
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,
                                                               const void *imageCreateInfoPNext);

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

// GL_ANGLE_memory_size

// 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 void *const *indices,
                                                 GLsizei drawcount);
angle::CallCapture CaptureMultiDrawElementsInstancedANGLE(const State &glState,
                                                          bool isCallValid,
                                                          PrimitiveMode modePacked,
                                                          const GLsizei *counts,
                                                          DrawElementsType typePacked,
                                                          const void *const *indices,
                                                          const GLsizei *instanceCounts,
                                                          GLsizei drawcount);

// GL_ANGLE_pack_reverse_row_order

// GL_ANGLE_polygon_mode
angle::CallCapture CapturePolygonModeANGLE(const State &glState,
                                           bool isCallValid,
                                           GLenum face,
                                           PolygonMode modePacked);

// GL_ANGLE_program_binary

// GL_ANGLE_program_binary_readiness_query

// GL_ANGLE_program_cache_control

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

// GL_ANGLE_renderability_validation

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

// GL_ANGLE_rgbx_internal_format

// GL_ANGLE_robust_client_memory
angle::CallCapture CaptureGetBooleanvRobustANGLE(const State &glState,
                                                 bool isCallValid,
                                                 GLenum pname,
                                                 GLsizei paramCount,
                                                 GLsizei *length,
                                                 GLboolean *data);
angle::CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState,
                                                          bool isCallValid,
                                                          BufferBinding targetPacked,
                                                          BufferParam pnamePacked,
                                                          GLsizei paramCount,
                                                          GLsizei *length,
                                                          GLint *params);
angle::CallCapture CaptureGetFloatvRobustANGLE(const State &glState,
                                               bool isCallValid,
                                               GLenum pname,
                                               GLsizei paramCount,
                                               GLsizei *length,
                                               GLfloat *data);
angle::CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState,
                                                                         bool isCallValid,
                                                                         GLenum target,
                                                                         GLenum attachment,
                                                                         GLenum pname,
                                                                         GLsizei paramCount,
                                                                         GLsizei *length,
                                                                         GLint *params);
angle::CallCapture CaptureGetIntegervRobustANGLE(const State &glState,
                                                 bool isCallValid,
                                                 GLenum pname,
                                                 GLsizei paramCount,
                                                 GLsizei *length,
                                                 GLint *data);
angle::CallCapture CaptureGetProgramivRobustANGLE(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLenum pname,
                                                  GLsizei paramCount,
                                                  GLsizei *length,
                                                  GLint *params);
angle::CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState,
                                                                bool isCallValid,
                                                                GLenum target,
                                                                GLenum pname,
                                                                GLsizei paramCount,
                                                                GLsizei *length,
                                                                GLint *params);
angle::CallCapture CaptureGetShaderivRobustANGLE(const State &glState,
                                                 bool isCallValid,
                                                 ShaderProgramID shaderPacked,
                                                 ShaderParameter pnamePacked,
                                                 GLsizei paramCount,
                                                 GLsizei *length,
                                                 GLint *params);
angle::CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       TextureType targetPacked,
                                                       GLenum pname,
                                                       GLsizei paramCount,
                                                       GLsizei *length,
                                                       GLfloat *params);
angle::CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       TextureType targetPacked,
                                                       GLenum pname,
                                                       GLsizei paramCount,
                                                       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 paramCount,
                                                       GLsizei *length,
                                                       GLfloat *params);
angle::CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       GLuint index,
                                                       GLenum pname,
                                                       GLsizei paramCount,
                                                       GLsizei *length,
                                                       GLint *params);
angle::CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState,
                                                             bool isCallValid,
                                                             GLuint index,
                                                             GLenum pname,
                                                             GLsizei paramCount,
                                                             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 paramCount,
                                                    const GLfloat *params);
angle::CallCapture CaptureTexParameterivRobustANGLE(const State &glState,
                                                    bool isCallValid,
                                                    TextureType targetPacked,
                                                    GLenum pname,
                                                    GLsizei paramCount,
                                                    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 CaptureGetQueryivRobustANGLE(const State &glState,
                                                bool isCallValid,
                                                QueryType targetPacked,
                                                QueryParameter pnamePacked,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLint *params);
angle::CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       QueryID idPacked,
                                                       QueryObjectParameter pnamePacked,
                                                       GLsizei paramCount,
                                                       GLsizei *length,
                                                       GLuint *params);
angle::CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState,
                                                       bool isCallValid,
                                                       BufferBinding targetPacked,
                                                       GLenum pname,
                                                       GLsizei paramCount,
                                                       GLsizei *length,
                                                       void **params);
angle::CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   GLenum target,
                                                   GLuint index,
                                                   GLsizei paramCount,
                                                   GLsizei *length,
                                                   GLint *data);
angle::CallCapture CaptureGetInternalformativRobustANGLE(const State &glState,
                                                         bool isCallValid,
                                                         GLenum target,
                                                         GLenum internalformat,
                                                         GLenum pname,
                                                         GLsizei paramCount,
                                                         GLsizei *length,
                                                         GLint *params);
angle::CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        GLuint index,
                                                        GLenum pname,
                                                        GLsizei paramCount,
                                                        GLsizei *length,
                                                        GLint *params);
angle::CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState,
                                                         bool isCallValid,
                                                         GLuint index,
                                                         GLenum pname,
                                                         GLsizei paramCount,
                                                         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,
    UniformBlockIndex uniformBlockIndexPacked,
    UniformBlockParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLint *params);
angle::CallCapture CaptureGetInteger64vRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   GLenum pname,
                                                   GLsizei paramCount,
                                                   GLsizei *length,
                                                   GLint64 *data);
angle::CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState,
                                                     bool isCallValid,
                                                     GLenum target,
                                                     GLuint index,
                                                     GLsizei paramCount,
                                                     GLsizei *length,
                                                     GLint64 *data);
angle::CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState,
                                                            bool isCallValid,
                                                            BufferBinding targetPacked,
                                                            BufferParam pnamePacked,
                                                            GLsizei paramCount,
                                                            GLsizei *length,
                                                            GLint64 *params);
angle::CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        SamplerID samplerPacked,
                                                        SamplerParameter pnamePacked,
                                                        GLsizei paramCount,
                                                        const GLint *param);
angle::CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        SamplerID samplerPacked,
                                                        SamplerParameter pnamePacked,
                                                        GLsizei paramCount,
                                                        const GLfloat *param);
angle::CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState,
                                                           bool isCallValid,
                                                           SamplerID samplerPacked,
                                                           SamplerParameter pnamePacked,
                                                           GLsizei paramCount,
                                                           GLsizei *length,
                                                           GLint *params);
angle::CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState,
                                                           bool isCallValid,
                                                           SamplerID samplerPacked,
                                                           SamplerParameter pnamePacked,
                                                           GLsizei paramCount,
                                                           GLsizei *length,
                                                           GLfloat *params);
angle::CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState,
                                                      bool isCallValid,
                                                      GLenum pname,
                                                      GLuint index,
                                                      GLsizei paramCount,
                                                      GLsizei *length,
                                                      GLfloat *val);
angle::CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState,
                                                            bool isCallValid,
                                                            TextureTarget targetPacked,
                                                            GLint level,
                                                            TextureImageParameter pnamePacked,
                                                            GLsizei paramCount,
                                                            GLsizei *length,
                                                            GLint *params);
angle::CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState,
                                                            bool isCallValid,
                                                            TextureTarget targetPacked,
                                                            GLint level,
                                                            TextureImageParameter pnamePacked,
                                                            GLsizei paramCount,
                                                            GLsizei *length,
                                                            GLfloat *params);
angle::CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState,
                                                      bool isCallValid,
                                                      QueryID idPacked,
                                                      QueryObjectParameter pnamePacked,
                                                      GLsizei paramCount,
                                                      GLsizei *length,
                                                      GLint *params);
angle::CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState,
                                                        bool isCallValid,
                                                        QueryID idPacked,
                                                        QueryObjectParameter pnamePacked,
                                                        GLsizei paramCount,
                                                        GLsizei *length,
                                                        GLint64 *params);
angle::CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState,
                                                         bool isCallValid,
                                                         QueryID idPacked,
                                                         QueryObjectParameter pnamePacked,
                                                         GLsizei paramCount,
                                                         GLsizei *length,
                                                         GLuint64 *params);
angle::CallCapture CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE(
    const State &glState,
    bool isCallValid,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLfloat *params);
angle::CallCapture CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE(
    const State &glState,
    bool isCallValid,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLint *params);
angle::CallCapture CaptureGetFramebufferPixelLocalStorageParameteruivRobustANGLE(
    const State &glState,
    bool isCallValid,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLuint *params);

// GL_ANGLE_robust_fragment_shader_output

// GL_ANGLE_robust_resource_initialization

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

// GL_ANGLE_shader_binary

// GL_ANGLE_shader_pixel_local_storage
angle::CallCapture CaptureFramebufferMemorylessPixelLocalStorageANGLE(const State &glState,
                                                                      bool isCallValid,
                                                                      GLint plane,
                                                                      GLenum internalformat,
                                                                      GLbitfield usage);
angle::CallCapture CaptureFramebufferTexturePixelLocalStorageANGLE(const State &glState,
                                                                   bool isCallValid,
                                                                   GLint plane,
                                                                   TextureID backingtexturePacked,
                                                                   GLint level,
                                                                   GLint layer,
                                                                   GLbitfield usage);
angle::CallCapture CaptureFramebufferPixelLocalClearValuefvANGLE(const State &glState,
                                                                 bool isCallValid,
                                                                 GLint plane,
                                                                 const GLfloat *value);
angle::CallCapture CaptureFramebufferPixelLocalClearValueivANGLE(const State &glState,
                                                                 bool isCallValid,
                                                                 GLint plane,
                                                                 const GLint *value);
angle::CallCapture CaptureFramebufferPixelLocalClearValueuivANGLE(const State &glState,
                                                                  bool isCallValid,
                                                                  GLint plane,
                                                                  const GLuint *value);
angle::CallCapture CaptureBeginPixelLocalStorageANGLE(const State &glState,
                                                      bool isCallValid,
                                                      GLsizei n,
                                                      const GLenum *loadops);
angle::CallCapture CaptureEndPixelLocalStorageANGLE(const State &glState,
                                                    bool isCallValid,
                                                    GLsizei n,
                                                    const GLenum *storeops);
angle::CallCapture CaptureEndPixelLocalStorageImplicitANGLE(const State &glState, bool isCallValid);
angle::CallCapture CapturePixelLocalStorageBarrierANGLE(const State &glState, bool isCallValid);
angle::CallCapture CaptureFramebufferPixelLocalStorageInterruptANGLE(const State &glState,
                                                                     bool isCallValid);
angle::CallCapture CaptureFramebufferPixelLocalStorageRestoreANGLE(const State &glState,
                                                                   bool isCallValid);
angle::CallCapture CaptureGetFramebufferPixelLocalStorageParameterfvANGLE(
    const State &glState,
    bool isCallValid,
    GLint plane,
    PlaneParameter pnamePacked,
    GLfloat *params);
angle::CallCapture CaptureGetFramebufferPixelLocalStorageParameterivANGLE(
    const State &glState,
    bool isCallValid,
    GLint plane,
    PlaneParameter pnamePacked,
    GLint *params);
angle::CallCapture CaptureGetFramebufferPixelLocalStorageParameteruivANGLE(
    const State &glState,
    bool isCallValid,
    GLint plane,
    PlaneParameter pnamePacked,
    GLuint *params);

// GL_ANGLE_stencil_texturing

// GL_ANGLE_texture_compression_dxt3

// GL_ANGLE_texture_compression_dxt5

// 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_texture_usage

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

// GL_ANGLE_vulkan_image
angle::CallCapture CaptureAcquireTexturesANGLE(const State &glState,
                                               bool isCallValid,
                                               GLuint numTextures,
                                               const TextureID *texturesPacked,
                                               const GLenum *layouts);
angle::CallCapture CaptureReleaseTexturesANGLE(const State &glState,
                                               bool isCallValid,
                                               GLuint numTextures,
                                               const TextureID *texturesPacked,
                                               GLenum *layouts);

// GL_ANGLE_yuv_internal_format

// GL_APPLE_clip_distance

// GL_ARM_rgba8

// GL_ARM_shader_framebuffer_fetch

// GL_ARM_shader_framebuffer_fetch_depth_stencil

// GL_ARM_texture_unnormalized_coordinates

// 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_EGL_image_storage
angle::CallCapture CaptureEGLImageTargetTexStorageEXT(const State &glState,
                                                      bool isCallValid,
                                                      GLenum target,
                                                      egl::ImageID imagePacked,
                                                      const GLint *attrib_list);

// GL_EXT_EGL_image_storage_compression

// GL_EXT_YUV_target

// GL_EXT_base_instance
angle::CallCapture CaptureDrawArraysInstancedBaseInstanceEXT(const State &glState,
                                                             bool isCallValid,
                                                             PrimitiveMode modePacked,
                                                             GLint first,
                                                             GLsizei count,
                                                             GLsizei instancecount,
                                                             GLuint baseinstance);
angle::CallCapture CaptureDrawElementsInstancedBaseInstanceEXT(const State &glState,
                                                               bool isCallValid,
                                                               PrimitiveMode modePacked,
                                                               GLsizei count,
                                                               DrawElementsType typePacked,
                                                               const void *indices,
                                                               GLsizei instancecount,
                                                               GLuint baseinstance);
angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT(
    const State &glState,
    bool isCallValid,
    PrimitiveMode modePacked,
    GLsizei count,
    DrawElementsType typePacked,
    const void *indices,
    GLsizei instancecount,
    GLint basevertex,
    GLuint baseinstance);

// 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_blend_minmax

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

// GL_EXT_clear_texture
angle::CallCapture CaptureClearTexImageEXT(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLint level,
                                           GLenum format,
                                           GLenum type,
                                           const void *data);
angle::CallCapture CaptureClearTexSubImageEXT(const State &glState,
                                              bool isCallValid,
                                              TextureID texturePacked,
                                              GLint level,
                                              GLint xoffset,
                                              GLint yoffset,
                                              GLint zoffset,
                                              GLsizei width,
                                              GLsizei height,
                                              GLsizei depth,
                                              GLenum format,
                                              GLenum type,
                                              const void *data);

// GL_EXT_clip_control
angle::CallCapture CaptureClipControlEXT(const State &glState,
                                         bool isCallValid,
                                         ClipOrigin originPacked,
                                         ClipDepthMode depthPacked);

// GL_EXT_clip_cull_distance

// GL_EXT_color_buffer_float

// GL_EXT_color_buffer_half_float

// GL_EXT_conservative_depth

// 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_label
angle::CallCapture CaptureGetObjectLabelEXT(const State &glState,
                                            bool isCallValid,
                                            GLenum type,
                                            GLuint object,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLchar *label);
angle::CallCapture CaptureLabelObjectEXT(const State &glState,
                                         bool isCallValid,
                                         GLenum type,
                                         GLuint object,
                                         GLsizei length,
                                         const GLchar *label);

// 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_depth_clamp

// 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,
                                                QueryObjectParameter pnamePacked,
                                                GLint64 *params);
angle::CallCapture CaptureGetQueryObjectivEXT(const State &glState,
                                              bool isCallValid,
                                              QueryID idPacked,
                                              QueryObjectParameter pnamePacked,
                                              GLint *params);
angle::CallCapture CaptureGetQueryObjectui64vEXT(const State &glState,
                                                 bool isCallValid,
                                                 QueryID idPacked,
                                                 QueryObjectParameter pnamePacked,
                                                 GLuint64 *params);
angle::CallCapture CaptureGetQueryObjectuivEXT(const State &glState,
                                               bool isCallValid,
                                               QueryID idPacked,
                                               QueryObjectParameter pnamePacked,
                                               GLuint *params);
angle::CallCapture CaptureGetQueryivEXT(const State &glState,
                                        bool isCallValid,
                                        QueryType targetPacked,
                                        QueryParameter pnamePacked,
                                        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 drawcount,
                                                         const GLint *basevertex);

// GL_EXT_draw_instanced
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);

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

// GL_EXT_float_blend

// GL_EXT_fragment_shading_rate
angle::CallCapture CaptureFramebufferShadingRateEXT(const State &glState,
                                                    bool isCallValid,
                                                    GLenum target,
                                                    GLenum attachment,
                                                    GLuint texture,
                                                    GLint baseLayer,
                                                    GLsizei numLayers,
                                                    GLsizei texelWidth,
                                                    GLsizei texelHeight);
angle::CallCapture CaptureGetFragmentShadingRatesEXT(const State &glState,
                                                     bool isCallValid,
                                                     GLsizei samples,
                                                     GLsizei maxCount,
                                                     GLsizei *count,
                                                     GLenum *shadingRates);
angle::CallCapture CaptureShadingRateEXT(const State &glState,
                                         bool isCallValid,
                                         ShadingRate ratePacked);
angle::CallCapture CaptureShadingRateCombinerOpsEXT(const State &glState,
                                                    bool isCallValid,
                                                    CombinerOp combinerOp0Packed,
                                                    CombinerOp combinerOp1Packed);

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

// GL_EXT_gpu_shader5

// GL_EXT_instanced_arrays
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_multi_draw_arrays
angle::CallCapture CaptureMultiDrawArraysEXT(const State &glState,
                                             bool isCallValid,
                                             PrimitiveMode modePacked,
                                             const GLint *first,
                                             const GLsizei *count,
                                             GLsizei primcount);
angle::CallCapture CaptureMultiDrawElementsEXT(const State &glState,
                                               bool isCallValid,
                                               PrimitiveMode modePacked,
                                               const GLsizei *count,
                                               DrawElementsType typePacked,
                                               const void *const *indices,
                                               GLsizei primcount);

// GL_EXT_multi_draw_indirect
angle::CallCapture CaptureMultiDrawArraysIndirectEXT(const State &glState,
                                                     bool isCallValid,
                                                     PrimitiveMode modePacked,
                                                     const void *indirect,
                                                     GLsizei drawcount,
                                                     GLsizei stride);
angle::CallCapture CaptureMultiDrawElementsIndirectEXT(const State &glState,
                                                       bool isCallValid,
                                                       PrimitiveMode modePacked,
                                                       DrawElementsType typePacked,
                                                       const void *indirect,
                                                       GLsizei drawcount,
                                                       GLsizei stride);

// 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_multisampled_render_to_texture2

// GL_EXT_occlusion_query_boolean

// GL_EXT_polygon_offset_clamp
angle::CallCapture CapturePolygonOffsetClampEXT(const State &glState,
                                                bool isCallValid,
                                                GLfloat factor,
                                                GLfloat units,
                                                GLfloat clamp);

// GL_EXT_primitive_bounding_box
angle::CallCapture CapturePrimitiveBoundingBoxEXT(const State &glState,
                                                  bool isCallValid,
                                                  GLfloat minX,
                                                  GLfloat minY,
                                                  GLfloat minZ,
                                                  GLfloat minW,
                                                  GLfloat maxX,
                                                  GLfloat maxY,
                                                  GLfloat maxZ,
                                                  GLfloat maxW);

// GL_EXT_protected_textures

// GL_EXT_pvrtc_sRGB

// GL_EXT_read_format_bgra

// GL_EXT_render_snorm

// 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_sRGB_write_control

// 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_separate_depth_stencil

// GL_EXT_separate_shader_objects
angle::CallCapture CaptureActiveShaderProgramEXT(const State &glState,
                                                 bool isCallValid,
                                                 ProgramPipelineID pipelinePacked,
                                                 ShaderProgramID programPacked);
angle::CallCapture CaptureBindProgramPipelineEXT(const State &glState,
                                                 bool isCallValid,
                                                 ProgramPipelineID pipelinePacked);
angle::CallCapture CaptureCreateShaderProgramvEXT(const State &glState,
                                                  bool isCallValid,
                                                  ShaderType typePacked,
                                                  GLsizei count,
                                                  const GLchar *const *strings,
                                                  GLuint returnValue);
angle::CallCapture CaptureDeleteProgramPipelinesEXT(const State &glState,
                                                    bool isCallValid,
                                                    GLsizei n,
                                                    const ProgramPipelineID *pipelinesPacked);
angle::CallCapture CaptureGenProgramPipelinesEXT(const State &glState,
                                                 bool isCallValid,
                                                 GLsizei n,
                                                 ProgramPipelineID *pipelinesPacked);
angle::CallCapture CaptureGetProgramPipelineInfoLogEXT(const State &glState,
                                                       bool isCallValid,
                                                       ProgramPipelineID pipelinePacked,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLchar *infoLog);
angle::CallCapture CaptureGetProgramPipelineivEXT(const State &glState,
                                                  bool isCallValid,
                                                  ProgramPipelineID pipelinePacked,
                                                  GLenum pname,
                                                  GLint *params);
angle::CallCapture CaptureIsProgramPipelineEXT(const State &glState,
                                               bool isCallValid,
                                               ProgramPipelineID pipelinePacked,
                                               GLboolean returnValue);
angle::CallCapture CaptureProgramParameteriEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               GLenum pname,
                                               GLint value);
angle::CallCapture CaptureProgramUniform1fEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              UniformLocation locationPacked,
                                              GLfloat v0);
angle::CallCapture CaptureProgramUniform1fvEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               const GLfloat *value);
angle::CallCapture CaptureProgramUniform1iEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              UniformLocation locationPacked,
                                              GLint v0);
angle::CallCapture CaptureProgramUniform1ivEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               const GLint *value);
angle::CallCapture CaptureProgramUniform1uiEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLuint v0);
angle::CallCapture CaptureProgramUniform1uivEXT(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                UniformLocation locationPacked,
                                                GLsizei count,
                                                const GLuint *value);
angle::CallCapture CaptureProgramUniform2fEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              UniformLocation locationPacked,
                                              GLfloat v0,
                                              GLfloat v1);
angle::CallCapture CaptureProgramUniform2fvEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               const GLfloat *value);
angle::CallCapture CaptureProgramUniform2iEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              UniformLocation locationPacked,
                                              GLint v0,
                                              GLint v1);
angle::CallCapture CaptureProgramUniform2ivEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               const GLint *value);
angle::CallCapture CaptureProgramUniform2uiEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLuint v0,
                                               GLuint v1);
angle::CallCapture CaptureProgramUniform2uivEXT(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                UniformLocation locationPacked,
                                                GLsizei count,
                                                const GLuint *value);
angle::CallCapture CaptureProgramUniform3fEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              UniformLocation locationPacked,
                                              GLfloat v0,
                                              GLfloat v1,
                                              GLfloat v2);
angle::CallCapture CaptureProgramUniform3fvEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               const GLfloat *value);
angle::CallCapture CaptureProgramUniform3iEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              UniformLocation locationPacked,
                                              GLint v0,
                                              GLint v1,
                                              GLint v2);
angle::CallCapture CaptureProgramUniform3ivEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               const GLint *value);
angle::CallCapture CaptureProgramUniform3uiEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLuint v0,
                                               GLuint v1,
                                               GLuint v2);
angle::CallCapture CaptureProgramUniform3uivEXT(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                UniformLocation locationPacked,
                                                GLsizei count,
                                                const GLuint *value);
angle::CallCapture CaptureProgramUniform4fEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              UniformLocation locationPacked,
                                              GLfloat v0,
                                              GLfloat v1,
                                              GLfloat v2,
                                              GLfloat v3);
angle::CallCapture CaptureProgramUniform4fvEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               const GLfloat *value);
angle::CallCapture CaptureProgramUniform4iEXT(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
                                              UniformLocation locationPacked,
                                              GLint v0,
                                              GLint v1,
                                              GLint v2,
                                              GLint v3);
angle::CallCapture CaptureProgramUniform4ivEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               const GLint *value);
angle::CallCapture CaptureProgramUniform4uiEXT(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLuint v0,
                                               GLuint v1,
                                               GLuint v2,
                                               GLuint v3);
angle::CallCapture CaptureProgramUniform4uivEXT(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                UniformLocation locationPacked,
                                                GLsizei count,
                                                const GLuint *value);
angle::CallCapture CaptureProgramUniformMatrix2fvEXT(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
                                                     UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
angle::CallCapture CaptureProgramUniformMatrix2x3fvEXT(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       UniformLocation locationPacked,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value);
angle::CallCapture CaptureProgramUniformMatrix2x4fvEXT(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       UniformLocation locationPacked,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value);
angle::CallCapture CaptureProgramUniformMatrix3fvEXT(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
                                                     UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
angle::CallCapture CaptureProgramUniformMatrix3x2fvEXT(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       UniformLocation locationPacked,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value);
angle::CallCapture CaptureProgramUniformMatrix3x4fvEXT(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       UniformLocation locationPacked,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value);
angle::CallCapture CaptureProgramUniformMatrix4fvEXT(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
                                                     UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
angle::CallCapture CaptureProgramUniformMatrix4x2fvEXT(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       UniformLocation locationPacked,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value);
angle::CallCapture CaptureProgramUniformMatrix4x3fvEXT(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
                                                       UniformLocation locationPacked,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value);
angle::CallCapture CaptureUseProgramStagesEXT(const State &glState,
                                              bool isCallValid,
                                              ProgramPipelineID pipelinePacked,
                                              GLbitfield stages,
                                              ShaderProgramID programPacked);
angle::CallCapture CaptureValidateProgramPipelineEXT(const State &glState,
                                                     bool isCallValid,
                                                     ProgramPipelineID pipelinePacked);

// GL_EXT_shader_framebuffer_fetch

// GL_EXT_shader_framebuffer_fetch_non_coherent
angle::CallCapture CaptureFramebufferFetchBarrierEXT(const State &glState, bool isCallValid);

// GL_EXT_shader_io_blocks

// GL_EXT_shader_non_constant_global_initializers

// GL_EXT_shader_texture_lod

// GL_EXT_shader_texture_samples

// GL_EXT_shadow_samplers

// GL_EXT_tessellation_shader
angle::CallCapture CapturePatchParameteriEXT(const State &glState,
                                             bool isCallValid,
                                             GLenum pname,
                                             GLint value);

// GL_EXT_texture_border_clamp
angle::CallCapture CaptureGetSamplerParameterIivEXT(const State &glState,
                                                    bool isCallValid,
                                                    SamplerID samplerPacked,
                                                    SamplerParameter pnamePacked,
                                                    GLint *params);
angle::CallCapture CaptureGetSamplerParameterIuivEXT(const State &glState,
                                                     bool isCallValid,
                                                     SamplerID samplerPacked,
                                                     SamplerParameter pnamePacked,
                                                     GLuint *params);
angle::CallCapture CaptureGetTexParameterIivEXT(const State &glState,
                                                bool isCallValid,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLint *params);
angle::CallCapture CaptureGetTexParameterIuivEXT(const State &glState,
                                                 bool isCallValid,
                                                 TextureType targetPacked,
                                                 GLenum pname,
                                                 GLuint *params);
angle::CallCapture CaptureSamplerParameterIivEXT(const State &glState,
                                                 bool isCallValid,
                                                 SamplerID samplerPacked,
                                                 SamplerParameter pnamePacked,
                                                 const GLint *param);
angle::CallCapture CaptureSamplerParameterIuivEXT(const State &glState,
                                                  bool isCallValid,
                                                  SamplerID samplerPacked,
                                                  SamplerParameter pnamePacked,
                                                  const GLuint *param);
angle::CallCapture CaptureTexParameterIivEXT(const State &glState,
                                             bool isCallValid,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             const GLint *params);
angle::CallCapture CaptureTexParameterIuivEXT(const State &glState,
                                              bool isCallValid,
                                              TextureType targetPacked,
                                              GLenum pname,
                                              const GLuint *params);

// 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_astc_decode_mode

// 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_filter_minmax

// GL_EXT_texture_format_BGRA8888

// GL_EXT_texture_format_sRGB_override

// GL_EXT_texture_lod_bias

// GL_EXT_texture_mirror_clamp_to_edge

// GL_EXT_texture_norm16

// GL_EXT_texture_query_lod

// GL_EXT_texture_rg

// GL_EXT_texture_sRGB_R8

// GL_EXT_texture_sRGB_RG8

// GL_EXT_texture_sRGB_decode

// GL_EXT_texture_shadow_lod

// GL_EXT_texture_storage
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_EXT_texture_storage_compression
angle::CallCapture CaptureTexStorageAttribs2DEXT(const State &glState,
                                                 bool isCallValid,
                                                 TextureType targetPacked,
                                                 GLsizei levels,
                                                 GLenum internalformat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 const GLint *attrib_list);
angle::CallCapture CaptureTexStorageAttribs3DEXT(const State &glState,
                                                 bool isCallValid,
                                                 TextureType targetPacked,
                                                 GLsizei levels,
                                                 GLenum internalformat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLsizei depth,
                                                 const GLint *attrib_list);

// GL_EXT_texture_type_2_10_10_10_REV

// GL_EXT_unpack_subimage

// GL_IMG_texture_compression_pvrtc

// GL_IMG_texture_compression_pvrtc2

// GL_KHR_blend_equation_advanced
angle::CallCapture CaptureBlendBarrierKHR(const State &glState, bool isCallValid);

// GL_KHR_blend_equation_advanced_coherent

// 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_no_error

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

// GL_KHR_robust_buffer_access_behavior

// GL_KHR_robustness
angle::CallCapture CaptureGetGraphicsResetStatusKHR(const State &glState,
                                                    bool isCallValid,
                                                    GLenum returnValue);
angle::CallCapture CaptureGetnUniformfvKHR(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLfloat *params);
angle::CallCapture CaptureGetnUniformivKHR(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLint *params);
angle::CallCapture CaptureGetnUniformuivKHR(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLuint *params);
angle::CallCapture CaptureReadnPixelsKHR(const State &glState,
                                         bool isCallValid,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         void *data);

// GL_KHR_texture_compression_astc_hdr

// GL_KHR_texture_compression_astc_ldr

// GL_KHR_texture_compression_astc_sliced_3d

// GL_MESA_framebuffer_flip_y
angle::CallCapture CaptureFramebufferParameteriMESA(const State &glState,
                                                    bool isCallValid,
                                                    GLenum target,
                                                    FramebufferParameter pnamePacked,
                                                    GLint param);
angle::CallCapture CaptureGetFramebufferParameterivMESA(const State &glState,
                                                        bool isCallValid,
                                                        GLenum target,
                                                        FramebufferParameter pnamePacked,
                                                        GLint *params);

// 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_NV_framebuffer_blit
angle::CallCapture CaptureBlitFramebufferNV(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_NV_pack_subimage

// GL_NV_pixel_buffer_object

// GL_NV_polygon_mode
angle::CallCapture CapturePolygonModeNV(const State &glState,
                                        bool isCallValid,
                                        GLenum face,
                                        PolygonMode modePacked);

// GL_NV_read_depth

// GL_NV_read_depth_stencil

// GL_NV_read_stencil

// GL_NV_robustness_video_memory_purge

// GL_NV_shader_noperspective_interpolation

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

// GL_OES_EGL_image_external

// GL_OES_EGL_image_external_essl3

// GL_OES_blend_subtract
angle::CallCapture CaptureBlendEquationOES(const State &glState, bool isCallValid, GLenum mode);

// GL_OES_compressed_ETC1_RGB8_texture

// GL_OES_compressed_paletted_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_depth24

// GL_OES_depth32

// GL_OES_depth_texture

// 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_element_index_uint

// GL_OES_fbo_render_mipmap

// 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_geometry_shader
angle::CallCapture CaptureFramebufferTextureOES(const State &glState,
                                                bool isCallValid,
                                                GLenum target,
                                                GLenum attachment,
                                                TextureID texturePacked,
                                                GLint level);

// 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_gpu_shader5

// 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_packed_depth_stencil

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

// GL_OES_point_sprite

// GL_OES_primitive_bounding_box
angle::CallCapture CapturePrimitiveBoundingBoxOES(const State &glState,
                                                  bool isCallValid,
                                                  GLfloat minX,
                                                  GLfloat minY,
                                                  GLfloat minZ,
                                                  GLfloat minW,
                                                  GLfloat maxX,
                                                  GLfloat maxY,
                                                  GLfloat maxZ,
                                                  GLfloat maxW);

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

// GL_OES_required_internalformat

// GL_OES_rgb8_rgba8

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

// GL_OES_sample_variables

// GL_OES_shader_image_atomic

// GL_OES_shader_io_blocks

// GL_OES_shader_multisample_interpolation

// GL_OES_standard_derivatives

// GL_OES_surfaceless_context

// GL_OES_tessellation_shader
angle::CallCapture CapturePatchParameteriOES(const State &glState,
                                             bool isCallValid,
                                             GLenum pname,
                                             GLint 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,
                                                    SamplerParameter pnamePacked,
                                                    GLint *params);
angle::CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
                                                     bool isCallValid,
                                                     SamplerID samplerPacked,
                                                     SamplerParameter pnamePacked,
                                                     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,
                                                 SamplerParameter pnamePacked,
                                                 const GLint *param);
angle::CallCapture CaptureSamplerParameterIuivOES(const State &glState,
                                                  bool isCallValid,
                                                  SamplerID samplerPacked,
                                                  SamplerParameter pnamePacked,
                                                  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_compression_astc

// 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_float

// GL_OES_texture_float_linear

// GL_OES_texture_half_float

// GL_OES_texture_half_float_linear

// GL_OES_texture_mirrored_repeat

// GL_OES_texture_npot

// 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_OES_vertex_half_float

// GL_OES_vertex_type_10_10_10_2

// 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

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

// GL_QCOM_framebuffer_foveated
angle::CallCapture CaptureFramebufferFoveationConfigQCOM(const State &glState,
                                                         bool isCallValid,
                                                         FramebufferID framebufferPacked,
                                                         GLuint numLayers,
                                                         GLuint focalPointsPerLayer,
                                                         GLuint requestedFeatures,
                                                         GLuint *providedFeatures);
angle::CallCapture CaptureFramebufferFoveationParametersQCOM(const State &glState,
                                                             bool isCallValid,
                                                             FramebufferID framebufferPacked,
                                                             GLuint layer,
                                                             GLuint focalPoint,
                                                             GLfloat focalX,
                                                             GLfloat focalY,
                                                             GLfloat gainX,
                                                             GLfloat gainY,
                                                             GLfloat foveaArea);

// GL_QCOM_render_shared_exponent

// GL_QCOM_shading_rate
angle::CallCapture CaptureShadingRateQCOM(const State &glState,
                                          bool isCallValid,
                                          ShadingRate ratePacked);

// GL_QCOM_texture_foveated
angle::CallCapture CaptureTextureFoveationParametersQCOM(const State &glState,
                                                         bool isCallValid,
                                                         TextureID texturePacked,
                                                         GLuint layer,
                                                         GLuint focalPoint,
                                                         GLfloat focalX,
                                                         GLfloat focalY,
                                                         GLfloat gainX,
                                                         GLfloat gainY,
                                                         GLfloat foveaArea);

// GL_QCOM_texture_lod_bias

// GL_QCOM_tiled_rendering
angle::CallCapture CaptureEndTilingQCOM(const State &glState,
                                        bool isCallValid,
                                        GLbitfield preserveMask);
angle::CallCapture CaptureStartTilingQCOM(const State &glState,
                                          bool isCallValid,
                                          GLuint x,
                                          GLuint y,
                                          GLuint width,
                                          GLuint height,
                                          GLbitfield preserveMask);

// Parameter Captures

void CaptureDeletePerfMonitorsAMD_monitors(const State &glState,
                                           GLsizei n,
                                           GLuint *monitors,
                                           angle::ParamCapture *paramCapture);
void CaptureGenPerfMonitorsAMD_monitors(const State &glState,
                                        GLsizei n,
                                        GLuint *monitors,
                                        angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorCounterDataAMD_data(const State &glState,
                                              GLuint monitor,
                                              GLenum pname,
                                              GLsizei dataSize,
                                              GLuint *data,
                                              GLint *bytesWritten,
                                              angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorCounterDataAMD_bytesWritten(const State &glState,
                                                      GLuint monitor,
                                                      GLenum pname,
                                                      GLsizei dataSize,
                                                      GLuint *data,
                                                      GLint *bytesWritten,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorCounterInfoAMD_data(const State &glState,
                                              GLuint group,
                                              GLuint counter,
                                              GLenum pname,
                                              void *data,
                                              angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorCounterStringAMD_length(const State &glState,
                                                  GLuint group,
                                                  GLuint counter,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLchar *counterString,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorCounterStringAMD_counterString(const State &glState,
                                                         GLuint group,
                                                         GLuint counter,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLchar *counterString,
                                                         angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorCountersAMD_numCounters(const State &glState,
                                                  GLuint group,
                                                  GLint *numCounters,
                                                  GLint *maxActiveCounters,
                                                  GLsizei counterSize,
                                                  GLuint *counters,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorCountersAMD_maxActiveCounters(const State &glState,
                                                        GLuint group,
                                                        GLint *numCounters,
                                                        GLint *maxActiveCounters,
                                                        GLsizei counterSize,
                                                        GLuint *counters,
                                                        angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorCountersAMD_counters(const State &glState,
                                               GLuint group,
                                               GLint *numCounters,
                                               GLint *maxActiveCounters,
                                               GLsizei counterSize,
                                               GLuint *counters,
                                               angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorGroupStringAMD_length(const State &glState,
                                                GLuint group,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLchar *groupString,
                                                angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorGroupStringAMD_groupString(const State &glState,
                                                     GLuint group,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLchar *groupString,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorGroupsAMD_numGroups(const State &glState,
                                              GLint *numGroups,
                                              GLsizei groupsSize,
                                              GLuint *groups,
                                              angle::ParamCapture *paramCapture);
void CaptureGetPerfMonitorGroupsAMD_groups(const State &glState,
                                           GLint *numGroups,
                                           GLsizei groupsSize,
                                           GLuint *groups,
                                           angle::ParamCapture *paramCapture);
void CaptureSelectPerfMonitorCountersAMD_counterList(const State &glState,
                                                     GLuint monitor,
                                                     GLboolean enable,
                                                     GLuint group,
                                                     GLint numCounters,
                                                     GLuint *counterList,
                                                     angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
    const State &glState,
    PrimitiveMode modePacked,
    GLsizei count,
    DrawElementsType typePacked,
    const void *indices,
    GLsizei instanceCount,
    GLint baseVertex,
    GLuint baseInstance,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(const State &glState,
                                                             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,
                                                             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,
    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,
    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,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const void *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
    const State &glState,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const void *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts(
    const State &glState,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const void *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices(
    const State &glState,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const void *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances(
    const State &glState,
    PrimitiveMode modePacked,
    const GLsizei *counts,
    DrawElementsType typePacked,
    const void *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount,
    angle::ParamCapture *paramCapture);
void CaptureBlobCacheCallbacksANGLE_userParam(const State &glState,
                                              GLSETBLOBPROCANGLE set,
                                              GLGETBLOBPROCANGLE get,
                                              const void *userParam,
                                              angle::ParamCapture *paramCapture);
void CaptureGetPointervANGLE_params(const State &glState,
                                    GLenum pname,
                                    void **params,
                                    angle::ParamCapture *paramCapture);
void CaptureGetTexImageANGLE_pixels(const State &glState,
                                    TextureTarget targetPacked,
                                    GLint level,
                                    GLenum format,
                                    GLenum type,
                                    void *pixels,
                                    angle::ParamCapture *paramCapture);
void CaptureGetCompressedTexImageANGLE_pixels(const State &glState,
                                              TextureTarget targetPacked,
                                              GLint level,
                                              void *pixels,
                                              angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferImageANGLE_pixels(const State &glState,
                                             GLenum target,
                                             GLenum format,
                                             GLenum type,
                                             void *pixels,
                                             angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivANGLE_params(const State &glState,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               TextureImageParameter pnamePacked,
                                               GLint *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvANGLE_params(const State &glState,
                                               TextureTarget targetPacked,
                                               GLint level,
                                               TextureImageParameter pnamePacked,
                                               GLfloat *params,
                                               angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedANGLE_indices(const State &glState,
                                               PrimitiveMode modePacked,
                                               GLsizei count,
                                               DrawElementsType typePacked,
                                               const void *indices,
                                               GLsizei primcount,
                                               angle::ParamCapture *paramCapture);
void CaptureTexStorageMemFlags2DANGLE_imageCreateInfoPNext(const State &glState,
                                                           TextureType targetPacked,
                                                           GLsizei levels,
                                                           GLenum internalFormat,
                                                           GLsizei width,
                                                           GLsizei height,
                                                           MemoryObjectID memoryPacked,
                                                           GLuint64 offset,
                                                           GLbitfield createFlags,
                                                           GLbitfield usageFlags,
                                                           const void *imageCreateInfoPNext,
                                                           angle::ParamCapture *paramCapture);
void CaptureTexStorageMemFlags2DMultisampleANGLE_imageCreateInfoPNext(
    const State &glState,
    TextureType targetPacked,
    GLsizei samples,
    GLenum internalFormat,
    GLsizei width,
    GLsizei height,
    GLboolean fixedSampleLocations,
    MemoryObjectID memoryPacked,
    GLuint64 offset,
    GLbitfield createFlags,
    GLbitfield usageFlags,
    const void *imageCreateInfoPNext,
    angle::ParamCapture *paramCapture);
void CaptureTexStorageMemFlags3DANGLE_imageCreateInfoPNext(const State &glState,
                                                           TextureType targetPacked,
                                                           GLsizei levels,
                                                           GLenum internalFormat,
                                                           GLsizei width,
                                                           GLsizei height,
                                                           GLsizei depth,
                                                           MemoryObjectID memoryPacked,
                                                           GLuint64 offset,
                                                           GLbitfield createFlags,
                                                           GLbitfield usageFlags,
                                                           const void *imageCreateInfoPNext,
                                                           angle::ParamCapture *paramCapture);
void CaptureTexStorageMemFlags3DMultisampleANGLE_imageCreateInfoPNext(
    const State &glState,
    TextureType targetPacked,
    GLsizei samples,
    GLenum internalFormat,
    GLsizei width,
    GLsizei height,
    GLsizei depth,
    GLboolean fixedSampleLocations,
    MemoryObjectID memoryPacked,
    GLuint64 offset,
    GLbitfield createFlags,
    GLbitfield usageFlags,
    const void *imageCreateInfoPNext,
    angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysANGLE_firsts(const State &glState,
                                        PrimitiveMode modePacked,
                                        const GLint *firsts,
                                        const GLsizei *counts,
                                        GLsizei drawcount,
                                        angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysANGLE_counts(const State &glState,
                                        PrimitiveMode modePacked,
                                        const GLint *firsts,
                                        const GLsizei *counts,
                                        GLsizei drawcount,
                                        angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_firsts(const State &glState,
                                                 PrimitiveMode modePacked,
                                                 const GLint *firsts,
                                                 const GLsizei *counts,
                                                 const GLsizei *instanceCounts,
                                                 GLsizei drawcount,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_counts(const State &glState,
                                                 PrimitiveMode modePacked,
                                                 const GLint *firsts,
                                                 const GLsizei *counts,
                                                 const GLsizei *instanceCounts,
                                                 GLsizei drawcount,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysInstancedANGLE_instanceCounts(const State &glState,
                                                         PrimitiveMode modePacked,
                                                         const GLint *firsts,
                                                         const GLsizei *counts,
                                                         const GLsizei *instanceCounts,
                                                         GLsizei drawcount,
                                                         angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsANGLE_counts(const State &glState,
                                          PrimitiveMode modePacked,
                                          const GLsizei *counts,
                                          DrawElementsType typePacked,
                                          const void *const *indices,
                                          GLsizei drawcount,
                                          angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsANGLE_indices(const State &glState,
                                           PrimitiveMode modePacked,
                                           const GLsizei *counts,
                                           DrawElementsType typePacked,
                                           const void *const *indices,
                                           GLsizei drawcount,
                                           angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedANGLE_counts(const State &glState,
                                                   PrimitiveMode modePacked,
                                                   const GLsizei *counts,
                                                   DrawElementsType typePacked,
                                                   const void *const *indices,
                                                   const GLsizei *instanceCounts,
                                                   GLsizei drawcount,
                                                   angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedANGLE_indices(const State &glState,
                                                    PrimitiveMode modePacked,
                                                    const GLsizei *counts,
                                                    DrawElementsType typePacked,
                                                    const void *const *indices,
                                                    const GLsizei *instanceCounts,
                                                    GLsizei drawcount,
                                                    angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsInstancedANGLE_instanceCounts(const State &glState,
                                                           PrimitiveMode modePacked,
                                                           const GLsizei *counts,
                                                           DrawElementsType typePacked,
                                                           const void *const *indices,
                                                           const GLsizei *instanceCounts,
                                                           GLsizei drawcount,
                                                           angle::ParamCapture *paramCapture);
void CaptureRequestExtensionANGLE_name(const State &glState,
                                       const GLchar *name,
                                       angle::ParamCapture *paramCapture);
void CaptureGetBooleanvRobustANGLE_length(const State &glState,
                                          GLenum pname,
                                          GLsizei paramCount,
                                          GLsizei *length,
                                          GLboolean *data,
                                          angle::ParamCapture *paramCapture);
void CaptureGetBooleanvRobustANGLE_data(const State &glState,
                                        GLenum pname,
                                        GLsizei paramCount,
                                        GLsizei *length,
                                        GLboolean *data,
                                        angle::ParamCapture *paramCapture);
void CaptureGetBufferParameterivRobustANGLE_length(const State &glState,
                                                   BufferBinding targetPacked,
                                                   BufferParam pnamePacked,
                                                   GLsizei paramCount,
                                                   GLsizei *length,
                                                   GLint *params,
                                                   angle::ParamCapture *paramCapture);
void CaptureGetBufferParameterivRobustANGLE_params(const State &glState,
                                                   BufferBinding targetPacked,
                                                   BufferParam pnamePacked,
                                                   GLsizei paramCount,
                                                   GLsizei *length,
                                                   GLint *params,
                                                   angle::ParamCapture *paramCapture);
void CaptureGetFloatvRobustANGLE_length(const State &glState,
                                        GLenum pname,
                                        GLsizei paramCount,
                                        GLsizei *length,
                                        GLfloat *data,
                                        angle::ParamCapture *paramCapture);
void CaptureGetFloatvRobustANGLE_data(const State &glState,
                                      GLenum pname,
                                      GLsizei paramCount,
                                      GLsizei *length,
                                      GLfloat *data,
                                      angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
    const State &glState,
    GLenum target,
    GLenum attachment,
    GLenum pname,
    GLsizei paramCount,
    GLsizei *length,
    GLint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
    const State &glState,
    GLenum target,
    GLenum attachment,
    GLenum pname,
    GLsizei paramCount,
    GLsizei *length,
    GLint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetIntegervRobustANGLE_length(const State &glState,
                                          GLenum pname,
                                          GLsizei paramCount,
                                          GLsizei *length,
                                          GLint *data,
                                          angle::ParamCapture *paramCapture);
void CaptureGetIntegervRobustANGLE_data(const State &glState,
                                        GLenum pname,
                                        GLsizei paramCount,
                                        GLsizei *length,
                                        GLint *data,
                                        angle::ParamCapture *paramCapture);
void CaptureGetProgramivRobustANGLE_length(const State &glState,
                                           ShaderProgramID programPacked,
                                           GLenum pname,
                                           GLsizei paramCount,
                                           GLsizei *length,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetProgramivRobustANGLE_params(const State &glState,
                                           ShaderProgramID programPacked,
                                           GLenum pname,
                                           GLsizei paramCount,
                                           GLsizei *length,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivRobustANGLE_length(const State &glState,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLsizei paramCount,
                                                         GLsizei *length,
                                                         GLint *params,
                                                         angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivRobustANGLE_params(const State &glState,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLsizei paramCount,
                                                         GLsizei *length,
                                                         GLint *params,
                                                         angle::ParamCapture *paramCapture);
void CaptureGetShaderivRobustANGLE_length(const State &glState,
                                          ShaderProgramID shaderPacked,
                                          ShaderParameter pnamePacked,
                                          GLsizei paramCount,
                                          GLsizei *length,
                                          GLint *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetShaderivRobustANGLE_params(const State &glState,
                                          ShaderProgramID shaderPacked,
                                          ShaderParameter pnamePacked,
                                          GLsizei paramCount,
                                          GLsizei *length,
                                          GLint *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetTexParameterfvRobustANGLE_length(const State &glState,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLfloat *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterfvRobustANGLE_params(const State &glState,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLfloat *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterivRobustANGLE_length(const State &glState,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetTexParameterivRobustANGLE_params(const State &glState,
                                                TextureType targetPacked,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetUniformfvRobustANGLE_length(const State &glState,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLfloat *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformfvRobustANGLE_params(const State &glState,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLfloat *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformivRobustANGLE_length(const State &glState,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetUniformivRobustANGLE_params(const State &glState,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribfvRobustANGLE_length(const State &glState,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLfloat *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribfvRobustANGLE_params(const State &glState,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLfloat *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribivRobustANGLE_length(const State &glState,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribivRobustANGLE_params(const State &glState,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribPointervRobustANGLE_length(const State &glState,
                                                      GLuint index,
                                                      GLenum pname,
                                                      GLsizei paramCount,
                                                      GLsizei *length,
                                                      void **pointer,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribPointervRobustANGLE_pointer(const State &glState,
                                                       GLuint index,
                                                       GLenum pname,
                                                       GLsizei paramCount,
                                                       GLsizei *length,
                                                       void **pointer,
                                                       angle::ParamCapture *paramCapture);
void CaptureReadPixelsRobustANGLE_length(const State &glState,
                                         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,
                                          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,
                                       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,
                                         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,
                                         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,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             GLsizei paramCount,
                                             const GLfloat *params,
                                             angle::ParamCapture *paramCapture);
void CaptureTexParameterivRobustANGLE_params(const State &glState,
                                             TextureType targetPacked,
                                             GLenum pname,
                                             GLsizei paramCount,
                                             const GLint *params,
                                             angle::ParamCapture *paramCapture);
void CaptureTexSubImage2DRobustANGLE_pixels(const State &glState,
                                            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,
                                         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,
                                            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 CaptureGetQueryivRobustANGLE_length(const State &glState,
                                         QueryType targetPacked,
                                         QueryParameter pnamePacked,
                                         GLsizei paramCount,
                                         GLsizei *length,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryivRobustANGLE_params(const State &glState,
                                         QueryType targetPacked,
                                         QueryParameter pnamePacked,
                                         GLsizei paramCount,
                                         GLsizei *length,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivRobustANGLE_length(const State &glState,
                                                QueryID idPacked,
                                                QueryObjectParameter pnamePacked,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLuint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivRobustANGLE_params(const State &glState,
                                                QueryID idPacked,
                                                QueryObjectParameter pnamePacked,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                GLuint *params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervRobustANGLE_length(const State &glState,
                                                BufferBinding targetPacked,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                void **params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervRobustANGLE_params(const State &glState,
                                                BufferBinding targetPacked,
                                                GLenum pname,
                                                GLsizei paramCount,
                                                GLsizei *length,
                                                void **params,
                                                angle::ParamCapture *paramCapture);
void CaptureGetIntegeri_vRobustANGLE_length(const State &glState,
                                            GLenum target,
                                            GLuint index,
                                            GLsizei paramCount,
                                            GLsizei *length,
                                            GLint *data,
                                            angle::ParamCapture *paramCapture);
void CaptureGetIntegeri_vRobustANGLE_data(const State &glState,
                                          GLenum target,
                                          GLuint index,
                                          GLsizei paramCount,
                                          GLsizei *length,
                                          GLint *data,
                                          angle::ParamCapture *paramCapture);
void CaptureGetInternalformativRobustANGLE_length(const State &glState,
                                                  GLenum target,
                                                  GLenum internalformat,
                                                  GLenum pname,
                                                  GLsizei paramCount,
                                                  GLsizei *length,
                                                  GLint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetInternalformativRobustANGLE_params(const State &glState,
                                                  GLenum target,
                                                  GLenum internalformat,
                                                  GLenum pname,
                                                  GLsizei paramCount,
                                                  GLsizei *length,
                                                  GLint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIivRobustANGLE_length(const State &glState,
                                                 GLuint index,
                                                 GLenum pname,
                                                 GLsizei paramCount,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIivRobustANGLE_params(const State &glState,
                                                 GLuint index,
                                                 GLenum pname,
                                                 GLsizei paramCount,
                                                 GLsizei *length,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIuivRobustANGLE_length(const State &glState,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLsizei paramCount,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetVertexAttribIuivRobustANGLE_params(const State &glState,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLsizei paramCount,
                                                  GLsizei *length,
                                                  GLuint *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetUniformuivRobustANGLE_length(const State &glState,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLuint *params,
                                            angle::ParamCapture *paramCapture);
void CaptureGetUniformuivRobustANGLE_params(const State &glState,
                                            ShaderProgramID programPacked,
                                            UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLuint *params,
                                            angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockivRobustANGLE_length(const State &glState,
                                                      ShaderProgramID programPacked,
                                                      UniformBlockIndex uniformBlockIndexPacked,
                                                      UniformBlockParameter pnamePacked,
                                                      GLsizei paramCount,
                                                      GLsizei *length,
                                                      GLint *params,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetActiveUniformBlockivRobustANGLE_params(const State &glState,
                                                      ShaderProgramID programPacked,
                                                      UniformBlockIndex uniformBlockIndexPacked,
                                                      UniformBlockParameter pnamePacked,
                                                      GLsizei paramCount,
                                                      GLsizei *length,
                                                      GLint *params,
                                                      angle::ParamCapture *paramCapture);
void CaptureGetInteger64vRobustANGLE_length(const State &glState,
                                            GLenum pname,
                                            GLsizei paramCount,
                                            GLsizei *length,
                                            GLint64 *data,
                                            angle::ParamCapture *paramCapture);
void CaptureGetInteger64vRobustANGLE_data(const State &glState,
                                          GLenum pname,
                                          GLsizei paramCount,
                                          GLsizei *length,
                                          GLint64 *data,
                                          angle::ParamCapture *paramCapture);
void CaptureGetInteger64i_vRobustANGLE_length(const State &glState,
                                              GLenum target,
                                              GLuint index,
                                              GLsizei paramCount,
                                              GLsizei *length,
                                              GLint64 *data,
                                              angle::ParamCapture *paramCapture);
void CaptureGetInteger64i_vRobustANGLE_data(const State &glState,
                                            GLenum target,
                                            GLuint index,
                                            GLsizei paramCount,
                                            GLsizei *length,
                                            GLint64 *data,
                                            angle::ParamCapture *paramCapture);
void CaptureGetBufferParameteri64vRobustANGLE_length(const State &glState,
                                                     BufferBinding targetPacked,
                                                     BufferParam pnamePacked,
                                                     GLsizei paramCount,
                                                     GLsizei *length,
                                                     GLint64 *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetBufferParameteri64vRobustANGLE_params(const State &glState,
                                                     BufferBinding targetPacked,
                                                     BufferParam pnamePacked,
                                                     GLsizei paramCount,
                                                     GLsizei *length,
                                                     GLint64 *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureSamplerParameterivRobustANGLE_param(const State &glState,
                                                SamplerID samplerPacked,
                                                SamplerParameter pnamePacked,
                                                GLsizei paramCount,
                                                const GLint *param,
                                                angle::ParamCapture *paramCapture);
void CaptureSamplerParameterfvRobustANGLE_param(const State &glState,
                                                SamplerID samplerPacked,
                                                SamplerParameter pnamePacked,
                                                GLsizei paramCount,
                                                const GLfloat *param,
                                                angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterivRobustANGLE_length(const State &glState,
                                                    SamplerID samplerPacked,
                                                    SamplerParameter pnamePacked,
                                                    GLsizei paramCount,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterivRobustANGLE_params(const State &glState,
                                                    SamplerID samplerPacked,
                                                    SamplerParameter pnamePacked,
                                                    GLsizei paramCount,
                                                    GLsizei *length,
                                                    GLint *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterfvRobustANGLE_length(const State &glState,
                                                    SamplerID samplerPacked,
                                                    SamplerParameter pnamePacked,
                                                    GLsizei paramCount,
                                                    GLsizei *length,
                                                    GLfloat *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterfvRobustANGLE_params(const State &glState,
                                                    SamplerID samplerPacked,
                                                    SamplerParameter pnamePacked,
                                                    GLsizei paramCount,
                                                    GLsizei *length,
                                                    GLfloat *params,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvRobustANGLE_length(const State &glState,
                                               GLenum pname,
                                               GLuint index,
                                               GLsizei paramCount,
                                               GLsizei *length,
                                               GLfloat *val,
                                               angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvRobustANGLE_val(const State &glState,
                                            GLenum pname,
                                            GLuint index,
                                            GLsizei paramCount,
                                            GLsizei *length,
                                            GLfloat *val,
                                            angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivRobustANGLE_length(const State &glState,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     TextureImageParameter pnamePacked,
                                                     GLsizei paramCount,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterivRobustANGLE_params(const State &glState,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     TextureImageParameter pnamePacked,
                                                     GLsizei paramCount,
                                                     GLsizei *length,
                                                     GLint *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvRobustANGLE_length(const State &glState,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     TextureImageParameter pnamePacked,
                                                     GLsizei paramCount,
                                                     GLsizei *length,
                                                     GLfloat *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetTexLevelParameterfvRobustANGLE_params(const State &glState,
                                                     TextureTarget targetPacked,
                                                     GLint level,
                                                     TextureImageParameter pnamePacked,
                                                     GLsizei paramCount,
                                                     GLsizei *length,
                                                     GLfloat *params,
                                                     angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivRobustANGLE_length(const State &glState,
                                               QueryID idPacked,
                                               QueryObjectParameter pnamePacked,
                                               GLsizei paramCount,
                                               GLsizei *length,
                                               GLint *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivRobustANGLE_params(const State &glState,
                                               QueryID idPacked,
                                               QueryObjectParameter pnamePacked,
                                               GLsizei paramCount,
                                               GLsizei *length,
                                               GLint *params,
                                               angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vRobustANGLE_length(const State &glState,
                                                 QueryID idPacked,
                                                 QueryObjectParameter pnamePacked,
                                                 GLsizei paramCount,
                                                 GLsizei *length,
                                                 GLint64 *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vRobustANGLE_params(const State &glState,
                                                 QueryID idPacked,
                                                 QueryObjectParameter pnamePacked,
                                                 GLsizei paramCount,
                                                 GLsizei *length,
                                                 GLint64 *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vRobustANGLE_length(const State &glState,
                                                  QueryID idPacked,
                                                  QueryObjectParameter pnamePacked,
                                                  GLsizei paramCount,
                                                  GLsizei *length,
                                                  GLuint64 *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vRobustANGLE_params(const State &glState,
                                                  QueryID idPacked,
                                                  QueryObjectParameter pnamePacked,
                                                  GLsizei paramCount,
                                                  GLsizei *length,
                                                  GLuint64 *params,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE_length(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLfloat *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameterfvRobustANGLE_params(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLfloat *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE_length(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameterivRobustANGLE_params(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameteruivRobustANGLE_length(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLuint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameteruivRobustANGLE_params(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLsizei paramCount,
    GLsizei *length,
    GLuint *params,
    angle::ParamCapture *paramCapture);
void CaptureFramebufferPixelLocalClearValuefvANGLE_value(const State &glState,
                                                         GLint plane,
                                                         const GLfloat *value,
                                                         angle::ParamCapture *paramCapture);
void CaptureFramebufferPixelLocalClearValueivANGLE_value(const State &glState,
                                                         GLint plane,
                                                         const GLint *value,
                                                         angle::ParamCapture *paramCapture);
void CaptureFramebufferPixelLocalClearValueuivANGLE_value(const State &glState,
                                                          GLint plane,
                                                          const GLuint *value,
                                                          angle::ParamCapture *paramCapture);
void CaptureBeginPixelLocalStorageANGLE_loadops(const State &glState,
                                                GLsizei n,
                                                const GLenum *loadops,
                                                angle::ParamCapture *paramCapture);
void CaptureEndPixelLocalStorageANGLE_storeops(const State &glState,
                                               GLsizei n,
                                               const GLenum *storeops,
                                               angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameterfvANGLE_params(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLfloat *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameterivANGLE_params(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferPixelLocalStorageParameteruivANGLE_params(
    const State &glState,
    GLint plane,
    PlaneParameter pnamePacked,
    GLuint *params,
    angle::ParamCapture *paramCapture);
void CaptureGetMultisamplefvANGLE_val(const State &glState,
                                      GLenum pname,
                                      GLuint index,
                                      GLfloat *val,
                                      angle::ParamCapture *paramCapture);
void CaptureGetTranslatedShaderSourceANGLE_length(const State &glState,
                                                  ShaderProgramID shaderPacked,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLchar *source,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetTranslatedShaderSourceANGLE_source(const State &glState,
                                                  ShaderProgramID shaderPacked,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLchar *source,
                                                  angle::ParamCapture *paramCapture);
void CaptureAcquireTexturesANGLE_texturesPacked(const State &glState,
                                                GLuint numTextures,
                                                const TextureID *texturesPacked,
                                                const GLenum *layouts,
                                                angle::ParamCapture *paramCapture);
void CaptureAcquireTexturesANGLE_layouts(const State &glState,
                                         GLuint numTextures,
                                         const TextureID *texturesPacked,
                                         const GLenum *layouts,
                                         angle::ParamCapture *paramCapture);
void CaptureReleaseTexturesANGLE_texturesPacked(const State &glState,
                                                GLuint numTextures,
                                                const TextureID *texturesPacked,
                                                GLenum *layouts,
                                                angle::ParamCapture *paramCapture);
void CaptureReleaseTexturesANGLE_layouts(const State &glState,
                                         GLuint numTextures,
                                         const TextureID *texturesPacked,
                                         GLenum *layouts,
                                         angle::ParamCapture *paramCapture);
void CaptureBindUniformLocationCHROMIUM_name(const State &glState,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             const GLchar *name,
                                             angle::ParamCapture *paramCapture);
void CaptureEGLImageTargetTexStorageEXT_attrib_list(const State &glState,
                                                    GLenum target,
                                                    egl::ImageID imagePacked,
                                                    const GLint *attrib_list,
                                                    angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedBaseInstanceEXT_indices(const State &glState,
                                                         PrimitiveMode modePacked,
                                                         GLsizei count,
                                                         DrawElementsType typePacked,
                                                         const void *indices,
                                                         GLsizei instancecount,
                                                         GLuint baseinstance,
                                                         angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT_indices(
    const State &glState,
    PrimitiveMode modePacked,
    GLsizei count,
    DrawElementsType typePacked,
    const void *indices,
    GLsizei instancecount,
    GLint basevertex,
    GLuint baseinstance,
    angle::ParamCapture *paramCapture);
void CaptureBindFragDataLocationEXT_name(const State &glState,
                                         ShaderProgramID programPacked,
                                         GLuint color,
                                         const GLchar *name,
                                         angle::ParamCapture *paramCapture);
void CaptureBindFragDataLocationIndexedEXT_name(const State &glState,
                                                ShaderProgramID programPacked,
                                                GLuint colorNumber,
                                                GLuint index,
                                                const GLchar *name,
                                                angle::ParamCapture *paramCapture);
void CaptureGetFragDataIndexEXT_name(const State &glState,
                                     ShaderProgramID programPacked,
                                     const GLchar *name,
                                     angle::ParamCapture *paramCapture);
void CaptureGetProgramResourceLocationIndexEXT_name(const State &glState,
                                                    ShaderProgramID programPacked,
                                                    GLenum programInterface,
                                                    const GLchar *name,
                                                    angle::ParamCapture *paramCapture);
void CaptureBufferStorageEXT_data(const State &glState,
                                  BufferBinding targetPacked,
                                  GLsizeiptr size,
                                  const void *data,
                                  GLbitfield flags,
                                  angle::ParamCapture *paramCapture);
void CaptureClearTexImageEXT_data(const State &glState,
                                  TextureID texturePacked,
                                  GLint level,
                                  GLenum format,
                                  GLenum type,
                                  const void *data,
                                  angle::ParamCapture *paramCapture);
void CaptureClearTexSubImageEXT_data(const State &glState,
                                     TextureID texturePacked,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint zoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLenum format,
                                     GLenum type,
                                     const void *data,
                                     angle::ParamCapture *paramCapture);
void CaptureGetObjectLabelEXT_length(const State &glState,
                                     GLenum type,
                                     GLuint object,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *label,
                                     angle::ParamCapture *paramCapture);
void CaptureGetObjectLabelEXT_label(const State &glState,
                                    GLenum type,
                                    GLuint object,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLchar *label,
                                    angle::ParamCapture *paramCapture);
void CaptureLabelObjectEXT_label(const State &glState,
                                 GLenum type,
                                 GLuint object,
                                 GLsizei length,
                                 const GLchar *label,
                                 angle::ParamCapture *paramCapture);
void CaptureInsertEventMarkerEXT_marker(const State &glState,
                                        GLsizei length,
                                        const GLchar *marker,
                                        angle::ParamCapture *paramCapture);
void CapturePushGroupMarkerEXT_marker(const State &glState,
                                      GLsizei length,
                                      const GLchar *marker,
                                      angle::ParamCapture *paramCapture);
void CaptureDiscardFramebufferEXT_attachments(const State &glState,
                                              GLenum target,
                                              GLsizei numAttachments,
                                              const GLenum *attachments,
                                              angle::ParamCapture *paramCapture);
void CaptureDeleteQueriesEXT_idsPacked(const State &glState,
                                       GLsizei n,
                                       const QueryID *idsPacked,
                                       angle::ParamCapture *paramCapture);
void CaptureGenQueriesEXT_idsPacked(const State &glState,
                                    GLsizei n,
                                    QueryID *idsPacked,
                                    angle::ParamCapture *paramCapture);
void CaptureGetInteger64vEXT_data(const State &glState,
                                  GLenum pname,
                                  GLint64 *data,
                                  angle::ParamCapture *paramCapture);
void CaptureGetQueryObjecti64vEXT_params(const State &glState,
                                         QueryID idPacked,
                                         QueryObjectParameter pnamePacked,
                                         GLint64 *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectivEXT_params(const State &glState,
                                       QueryID idPacked,
                                       QueryObjectParameter pnamePacked,
                                       GLint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectui64vEXT_params(const State &glState,
                                          QueryID idPacked,
                                          QueryObjectParameter pnamePacked,
                                          GLuint64 *params,
                                          angle::ParamCapture *paramCapture);
void CaptureGetQueryObjectuivEXT_params(const State &glState,
                                        QueryID idPacked,
                                        QueryObjectParameter pnamePacked,
                                        GLuint *params,
                                        angle::ParamCapture *paramCapture);
void CaptureGetQueryivEXT_params(const State &glState,
                                 QueryType targetPacked,
                                 QueryParameter pnamePacked,
                                 GLint *params,
                                 angle::ParamCapture *paramCapture);
void CaptureDrawBuffersEXT_bufs(const State &glState,
                                GLsizei n,
                                const GLenum *bufs,
                                angle::ParamCapture *paramCapture);
void CaptureDrawElementsBaseVertexEXT_indices(const State &glState,
                                              PrimitiveMode modePacked,
                                              GLsizei count,
                                              DrawElementsType typePacked,
                                              const void *indices,
                                              GLint basevertex,
                                              angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedBaseVertexEXT_indices(const State &glState,
                                                       PrimitiveMode modePacked,
                                                       GLsizei count,
                                                       DrawElementsType typePacked,
                                                       const void *indices,
                                                       GLsizei instancecount,
                                                       GLint basevertex,
                                                       angle::ParamCapture *paramCapture);
void CaptureDrawRangeElementsBaseVertexEXT_indices(const State &glState,
                                                   PrimitiveMode modePacked,
                                                   GLuint start,
                                                   GLuint end,
                                                   GLsizei count,
                                                   DrawElementsType typePacked,
                                                   const void *indices,
                                                   GLint basevertex,
                                                   angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsBaseVertexEXT_count(const State &glState,
                                                 PrimitiveMode modePacked,
                                                 const GLsizei *count,
                                                 DrawElementsType typePacked,
                                                 const void *const *indices,
                                                 GLsizei drawcount,
                                                 const GLint *basevertex,
                                                 angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsBaseVertexEXT_indices(const State &glState,
                                                   PrimitiveMode modePacked,
                                                   const GLsizei *count,
                                                   DrawElementsType typePacked,
                                                   const void *const *indices,
                                                   GLsizei drawcount,
                                                   const GLint *basevertex,
                                                   angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsBaseVertexEXT_basevertex(const State &glState,
                                                      PrimitiveMode modePacked,
                                                      const GLsizei *count,
                                                      DrawElementsType typePacked,
                                                      const void *const *indices,
                                                      GLsizei drawcount,
                                                      const GLint *basevertex,
                                                      angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedEXT_indices(const State &glState,
                                             PrimitiveMode modePacked,
                                             GLsizei count,
                                             DrawElementsType typePacked,
                                             const void *indices,
                                             GLsizei primcount,
                                             angle::ParamCapture *paramCapture);
void CaptureGetFragmentShadingRatesEXT_count(const State &glState,
                                             GLsizei samples,
                                             GLsizei maxCount,
                                             GLsizei *count,
                                             GLenum *shadingRates,
                                             angle::ParamCapture *paramCapture);
void CaptureGetFragmentShadingRatesEXT_shadingRates(const State &glState,
                                                    GLsizei samples,
                                                    GLsizei maxCount,
                                                    GLsizei *count,
                                                    GLenum *shadingRates,
                                                    angle::ParamCapture *paramCapture);
void CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(const State &glState,
                                                       GLsizei n,
                                                       MemoryObjectID *memoryObjectsPacked,
                                                       angle::ParamCapture *paramCapture);
void CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(const State &glState,
                                                       GLsizei n,
                                                       const MemoryObjectID *memoryObjectsPacked,
                                                       angle::ParamCapture *paramCapture);
void CaptureGetMemoryObjectParameterivEXT_params(const State &glState,
                                                 MemoryObjectID memoryObjectPacked,
                                                 GLenum pname,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetUnsignedBytevEXT_data(const State &glState,
                                     GLenum pname,
                                     GLubyte *data,
                                     angle::ParamCapture *paramCapture);
void CaptureGetUnsignedBytei_vEXT_data(const State &glState,
                                       GLenum target,
                                       GLuint index,
                                       GLubyte *data,
                                       angle::ParamCapture *paramCapture);
void CaptureMemoryObjectParameterivEXT_params(const State &glState,
                                              MemoryObjectID memoryObjectPacked,
                                              GLenum pname,
                                              const GLint *params,
                                              angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysEXT_first(const State &glState,
                                     PrimitiveMode modePacked,
                                     const GLint *first,
                                     const GLsizei *count,
                                     GLsizei primcount,
                                     angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysEXT_count(const State &glState,
                                     PrimitiveMode modePacked,
                                     const GLint *first,
                                     const GLsizei *count,
                                     GLsizei primcount,
                                     angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsEXT_count(const State &glState,
                                       PrimitiveMode modePacked,
                                       const GLsizei *count,
                                       DrawElementsType typePacked,
                                       const void *const *indices,
                                       GLsizei primcount,
                                       angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsEXT_indices(const State &glState,
                                         PrimitiveMode modePacked,
                                         const GLsizei *count,
                                         DrawElementsType typePacked,
                                         const void *const *indices,
                                         GLsizei primcount,
                                         angle::ParamCapture *paramCapture);
void CaptureMultiDrawArraysIndirectEXT_indirect(const State &glState,
                                                PrimitiveMode modePacked,
                                                const void *indirect,
                                                GLsizei drawcount,
                                                GLsizei stride,
                                                angle::ParamCapture *paramCapture);
void CaptureMultiDrawElementsIndirectEXT_indirect(const State &glState,
                                                  PrimitiveMode modePacked,
                                                  DrawElementsType typePacked,
                                                  const void *indirect,
                                                  GLsizei drawcount,
                                                  GLsizei stride,
                                                  angle::ParamCapture *paramCapture);
void CaptureGetnUniformfvEXT_params(const State &glState,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei bufSize,
                                    GLfloat *params,
                                    angle::ParamCapture *paramCapture);
void CaptureGetnUniformivEXT_params(const State &glState,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei bufSize,
                                    GLint *params,
                                    angle::ParamCapture *paramCapture);
void CaptureReadnPixelsEXT_data(const State &glState,
                                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,
                                                 GLsizei n,
                                                 const SemaphoreID *semaphoresPacked,
                                                 angle::ParamCapture *paramCapture);
void CaptureGenSemaphoresEXT_semaphoresPacked(const State &glState,
                                              GLsizei n,
                                              SemaphoreID *semaphoresPacked,
                                              angle::ParamCapture *paramCapture);
void CaptureGetSemaphoreParameterui64vEXT_params(const State &glState,
                                                 SemaphoreID semaphorePacked,
                                                 GLenum pname,
                                                 GLuint64 *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureSemaphoreParameterui64vEXT_params(const State &glState,
                                              SemaphoreID semaphorePacked,
                                              GLenum pname,
                                              const GLuint64 *params,
                                              angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_buffersPacked(const State &glState,
                                             SemaphoreID semaphorePacked,
                                             GLuint numBufferBarriers,
                                             const BufferID *buffersPacked,
                                             GLuint numTextureBarriers,
                                             const TextureID *texturesPacked,
                                             const GLenum *dstLayouts,
                                             angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_texturesPacked(const State &glState,
                                              SemaphoreID semaphorePacked,
                                              GLuint numBufferBarriers,
                                              const BufferID *buffersPacked,
                                              GLuint numTextureBarriers,
                                              const TextureID *texturesPacked,
                                              const GLenum *dstLayouts,
                                              angle::ParamCapture *paramCapture);
void CaptureSignalSemaphoreEXT_dstLayouts(const State &glState,
                                          SemaphoreID semaphorePacked,
                                          GLuint numBufferBarriers,
                                          const BufferID *buffersPacked,
                                          GLuint numTextureBarriers,
                                          const TextureID *texturesPacked,
                                          const GLenum *dstLayouts,
                                          angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_buffersPacked(const State &glState,
                                           SemaphoreID semaphorePacked,
                                           GLuint numBufferBarriers,
                                           const BufferID *buffersPacked,
                                           GLuint numTextureBarriers,
                                           const TextureID *texturesPacked,
                                           const GLenum *srcLayouts,
                                           angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_texturesPacked(const State &glState,
                                            SemaphoreID semaphorePacked,
                                            GLuint numBufferBarriers,
                                            const BufferID *buffersPacked,
                                            GLuint numTextureBarriers,
                                            const TextureID *texturesPacked,
                                            const GLenum *srcLayouts,
                                            angle::ParamCapture *paramCapture);
void CaptureWaitSemaphoreEXT_srcLayouts(const State &glState,
                                        SemaphoreID semaphorePacked,
                                        GLuint numBufferBarriers,
                                        const BufferID *buffersPacked,
                                        GLuint numTextureBarriers,
                                        const TextureID *texturesPacked,
                                        const GLenum *srcLayouts,
                                        angle::ParamCapture *paramCapture);
void CaptureCreateShaderProgramvEXT_strings(const State &glState,
                                            ShaderType typePacked,
                                            GLsizei count,
                                            const GLchar *const *strings,
                                            angle::ParamCapture *paramCapture);
void CaptureDeleteProgramPipelinesEXT_pipelinesPacked(const State &glState,
                                                      GLsizei n,
                                                      const ProgramPipelineID *pipelinesPacked,
                                                      angle::ParamCapture *paramCapture);
void CaptureGenProgramPipelinesEXT_pipelinesPacked(const State &glState,
                                                   GLsizei n,
                                                   ProgramPipelineID *pipelinesPacked,
                                                   angle::ParamCapture *paramCapture);
void CaptureGetProgramPipelineInfoLogEXT_length(const State &glState,
                                                ProgramPipelineID pipelinePacked,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLchar *infoLog,
                                                angle::ParamCapture *paramCapture);
void CaptureGetProgramPipelineInfoLogEXT_infoLog(const State &glState,
                                                 ProgramPipelineID pipelinePacked,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLchar *infoLog,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetProgramPipelineivEXT_params(const State &glState,
                                           ProgramPipelineID pipelinePacked,
                                           GLenum pname,
                                           GLint *params,
                                           angle::ParamCapture *paramCapture);
void CaptureProgramUniform1fvEXT_value(const State &glState,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLfloat *value,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramUniform1ivEXT_value(const State &glState,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLint *value,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramUniform1uivEXT_value(const State &glState,
                                        ShaderProgramID programPacked,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        const GLuint *value,
                                        angle::ParamCapture *paramCapture);
void CaptureProgramUniform2fvEXT_value(const State &glState,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLfloat *value,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramUniform2ivEXT_value(const State &glState,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLint *value,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramUniform2uivEXT_value(const State &glState,
                                        ShaderProgramID programPacked,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        const GLuint *value,
                                        angle::ParamCapture *paramCapture);
void CaptureProgramUniform3fvEXT_value(const State &glState,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLfloat *value,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramUniform3ivEXT_value(const State &glState,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLint *value,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramUniform3uivEXT_value(const State &glState,
                                        ShaderProgramID programPacked,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        const GLuint *value,
                                        angle::ParamCapture *paramCapture);
void CaptureProgramUniform4fvEXT_value(const State &glState,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLfloat *value,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramUniform4ivEXT_value(const State &glState,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLint *value,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramUniform4uivEXT_value(const State &glState,
                                        ShaderProgramID programPacked,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        const GLuint *value,
                                        angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix2fvEXT_value(const State &glState,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
                                             angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix2x3fvEXT_value(const State &glState,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLfloat *value,
                                               angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix2x4fvEXT_value(const State &glState,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLfloat *value,
                                               angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix3fvEXT_value(const State &glState,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
                                             angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix3x2fvEXT_value(const State &glState,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLfloat *value,
                                               angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix3x4fvEXT_value(const State &glState,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLfloat *value,
                                               angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix4fvEXT_value(const State &glState,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
                                             angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix4x2fvEXT_value(const State &glState,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLfloat *value,
                                               angle::ParamCapture *paramCapture);
void CaptureProgramUniformMatrix4x3fvEXT_value(const State &glState,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLfloat *value,
                                               angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIivEXT_params(const State &glState,
                                             SamplerID samplerPacked,
                                             SamplerParameter pnamePacked,
                                             GLint *params,
                                             angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIuivEXT_params(const State &glState,
                                              SamplerID samplerPacked,
                                              SamplerParameter pnamePacked,
                                              GLuint *params,
                                              angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIivEXT_params(const State &glState,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIuivEXT_params(const State &glState,
                                          TextureType targetPacked,
                                          GLenum pname,
                                          GLuint *params,
                                          angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIivEXT_param(const State &glState,
                                         SamplerID samplerPacked,
                                         SamplerParameter pnamePacked,
                                         const GLint *param,
                                         angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIuivEXT_param(const State &glState,
                                          SamplerID samplerPacked,
                                          SamplerParameter pnamePacked,
                                          const GLuint *param,
                                          angle::ParamCapture *paramCapture);
void CaptureTexParameterIivEXT_params(const State &glState,
                                      TextureType targetPacked,
                                      GLenum pname,
                                      const GLint *params,
                                      angle::ParamCapture *paramCapture);
void CaptureTexParameterIuivEXT_params(const State &glState,
                                       TextureType targetPacked,
                                       GLenum pname,
                                       const GLuint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureTexStorageAttribs2DEXT_attrib_list(const State &glState,
                                               TextureType targetPacked,
                                               GLsizei levels,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               const GLint *attrib_list,
                                               angle::ParamCapture *paramCapture);
void CaptureTexStorageAttribs3DEXT_attrib_list(const State &glState,
                                               TextureType targetPacked,
                                               GLsizei levels,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               GLsizei depth,
                                               const GLint *attrib_list,
                                               angle::ParamCapture *paramCapture);
void CaptureDebugMessageCallbackKHR_userParam(const State &glState,
                                              GLDEBUGPROCKHR callback,
                                              const void *userParam,
                                              angle::ParamCapture *paramCapture);
void CaptureDebugMessageControlKHR_ids(const State &glState,
                                       GLenum source,
                                       GLenum type,
                                       GLenum severity,
                                       GLsizei count,
                                       const GLuint *ids,
                                       GLboolean enabled,
                                       angle::ParamCapture *paramCapture);
void CaptureDebugMessageInsertKHR_buf(const State &glState,
                                      GLenum source,
                                      GLenum type,
                                      GLuint id,
                                      GLenum severity,
                                      GLsizei length,
                                      const GLchar *buf,
                                      angle::ParamCapture *paramCapture);
void CaptureGetDebugMessageLogKHR_sources(const State &glState,
                                          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,
                                        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,
                                      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,
                                             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,
                                          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,
                                             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,
                                     GLenum identifier,
                                     GLuint name,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *label,
                                     angle::ParamCapture *paramCapture);
void CaptureGetObjectLabelKHR_label(const State &glState,
                                    GLenum identifier,
                                    GLuint name,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLchar *label,
                                    angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_ptr(const State &glState,
                                     const void *ptr,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *label,
                                     angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_length(const State &glState,
                                        const void *ptr,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLchar *label,
                                        angle::ParamCapture *paramCapture);
void CaptureGetObjectPtrLabelKHR_label(const State &glState,
                                       const void *ptr,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLchar *label,
                                       angle::ParamCapture *paramCapture);
void CaptureGetPointervKHR_params(const State &glState,
                                  GLenum pname,
                                  void **params,
                                  angle::ParamCapture *paramCapture);
void CaptureObjectLabelKHR_label(const State &glState,
                                 GLenum identifier,
                                 GLuint name,
                                 GLsizei length,
                                 const GLchar *label,
                                 angle::ParamCapture *paramCapture);
void CaptureObjectPtrLabelKHR_ptr(const State &glState,
                                  const void *ptr,
                                  GLsizei length,
                                  const GLchar *label,
                                  angle::ParamCapture *paramCapture);
void CaptureObjectPtrLabelKHR_label(const State &glState,
                                    const void *ptr,
                                    GLsizei length,
                                    const GLchar *label,
                                    angle::ParamCapture *paramCapture);
void CapturePushDebugGroupKHR_message(const State &glState,
                                      GLenum source,
                                      GLuint id,
                                      GLsizei length,
                                      const GLchar *message,
                                      angle::ParamCapture *paramCapture);
void CaptureGetnUniformfvKHR_params(const State &glState,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei bufSize,
                                    GLfloat *params,
                                    angle::ParamCapture *paramCapture);
void CaptureGetnUniformivKHR_params(const State &glState,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLsizei bufSize,
                                    GLint *params,
                                    angle::ParamCapture *paramCapture);
void CaptureGetnUniformuivKHR_params(const State &glState,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei bufSize,
                                     GLuint *params,
                                     angle::ParamCapture *paramCapture);
void CaptureReadnPixelsKHR_data(const State &glState,
                                GLint x,
                                GLint y,
                                GLsizei width,
                                GLsizei height,
                                GLenum format,
                                GLenum type,
                                GLsizei bufSize,
                                void *data,
                                angle::ParamCapture *paramCapture);
void CaptureGetFramebufferParameterivMESA_params(const State &glState,
                                                 GLenum target,
                                                 FramebufferParameter pnamePacked,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureDeleteFencesNV_fencesPacked(const State &glState,
                                        GLsizei n,
                                        const FenceNVID *fencesPacked,
                                        angle::ParamCapture *paramCapture);
void CaptureGenFencesNV_fencesPacked(const State &glState,
                                     GLsizei n,
                                     FenceNVID *fencesPacked,
                                     angle::ParamCapture *paramCapture);
void CaptureGetFenceivNV_params(const State &glState,
                                FenceNVID fencePacked,
                                GLenum pname,
                                GLint *params,
                                angle::ParamCapture *paramCapture);
void CaptureDrawElementsBaseVertexOES_indices(const State &glState,
                                              PrimitiveMode modePacked,
                                              GLsizei count,
                                              DrawElementsType typePacked,
                                              const void *indices,
                                              GLint basevertex,
                                              angle::ParamCapture *paramCapture);
void CaptureDrawElementsInstancedBaseVertexOES_indices(const State &glState,
                                                       PrimitiveMode modePacked,
                                                       GLsizei count,
                                                       DrawElementsType typePacked,
                                                       const void *indices,
                                                       GLsizei instancecount,
                                                       GLint basevertex,
                                                       angle::ParamCapture *paramCapture);
void CaptureDrawRangeElementsBaseVertexOES_indices(const State &glState,
                                                   PrimitiveMode modePacked,
                                                   GLuint start,
                                                   GLuint end,
                                                   GLsizei count,
                                                   DrawElementsType typePacked,
                                                   const void *indices,
                                                   GLint basevertex,
                                                   angle::ParamCapture *paramCapture);
void CaptureDrawTexfvOES_coords(const State &glState,
                                const GLfloat *coords,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexivOES_coords(const State &glState,
                                const GLint *coords,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexsvOES_coords(const State &glState,
                                const GLshort *coords,
                                angle::ParamCapture *paramCapture);
void CaptureDrawTexxvOES_coords(const State &glState,
                                const GLfixed *coords,
                                angle::ParamCapture *paramCapture);
void CaptureDeleteFramebuffersOES_framebuffersPacked(const State &glState,
                                                     GLsizei n,
                                                     const FramebufferID *framebuffersPacked,
                                                     angle::ParamCapture *paramCapture);
void CaptureDeleteRenderbuffersOES_renderbuffersPacked(const State &glState,
                                                       GLsizei n,
                                                       const RenderbufferID *renderbuffersPacked,
                                                       angle::ParamCapture *paramCapture);
void CaptureGenFramebuffersOES_framebuffersPacked(const State &glState,
                                                  GLsizei n,
                                                  FramebufferID *framebuffersPacked,
                                                  angle::ParamCapture *paramCapture);
void CaptureGenRenderbuffersOES_renderbuffersPacked(const State &glState,
                                                    GLsizei n,
                                                    RenderbufferID *renderbuffersPacked,
                                                    angle::ParamCapture *paramCapture);
void CaptureGetFramebufferAttachmentParameterivOES_params(const State &glState,
                                                          GLenum target,
                                                          GLenum attachment,
                                                          GLenum pname,
                                                          GLint *params,
                                                          angle::ParamCapture *paramCapture);
void CaptureGetRenderbufferParameterivOES_params(const State &glState,
                                                 GLenum target,
                                                 GLenum pname,
                                                 GLint *params,
                                                 angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_length(const State &glState,
                                       ShaderProgramID programPacked,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLenum *binaryFormat,
                                       void *binary,
                                       angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_binaryFormat(const State &glState,
                                             ShaderProgramID programPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLenum *binaryFormat,
                                             void *binary,
                                             angle::ParamCapture *paramCapture);
void CaptureGetProgramBinaryOES_binary(const State &glState,
                                       ShaderProgramID programPacked,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLenum *binaryFormat,
                                       void *binary,
                                       angle::ParamCapture *paramCapture);
void CaptureProgramBinaryOES_binary(const State &glState,
                                    ShaderProgramID programPacked,
                                    GLenum binaryFormat,
                                    const void *binary,
                                    GLint length,
                                    angle::ParamCapture *paramCapture);
void CaptureGetBufferPointervOES_params(const State &glState,
                                        BufferBinding targetPacked,
                                        GLenum pname,
                                        void **params,
                                        angle::ParamCapture *paramCapture);
void CaptureMatrixIndexPointerOES_pointer(const State &glState,
                                          GLint size,
                                          GLenum type,
                                          GLsizei stride,
                                          const void *pointer,
                                          angle::ParamCapture *paramCapture);
void CaptureWeightPointerOES_pointer(const State &glState,
                                     GLint size,
                                     GLenum type,
                                     GLsizei stride,
                                     const void *pointer,
                                     angle::ParamCapture *paramCapture);
void CapturePointSizePointerOES_pointer(const State &glState,
                                        VertexAttribType typePacked,
                                        GLsizei stride,
                                        const void *pointer,
                                        angle::ParamCapture *paramCapture);
void CaptureQueryMatrixxOES_mantissa(const State &glState,
                                     GLfixed *mantissa,
                                     GLint *exponent,
                                     angle::ParamCapture *paramCapture);
void CaptureQueryMatrixxOES_exponent(const State &glState,
                                     GLfixed *mantissa,
                                     GLint *exponent,
                                     angle::ParamCapture *paramCapture);
void CaptureCompressedTexImage3DOES_data(const State &glState,
                                         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,
                                            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,
                                 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,
                                    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,
                                             SamplerID samplerPacked,
                                             SamplerParameter pnamePacked,
                                             GLint *params,
                                             angle::ParamCapture *paramCapture);
void CaptureGetSamplerParameterIuivOES_params(const State &glState,
                                              SamplerID samplerPacked,
                                              SamplerParameter pnamePacked,
                                              GLuint *params,
                                              angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIivOES_params(const State &glState,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         GLint *params,
                                         angle::ParamCapture *paramCapture);
void CaptureGetTexParameterIuivOES_params(const State &glState,
                                          TextureType targetPacked,
                                          GLenum pname,
                                          GLuint *params,
                                          angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIivOES_param(const State &glState,
                                         SamplerID samplerPacked,
                                         SamplerParameter pnamePacked,
                                         const GLint *param,
                                         angle::ParamCapture *paramCapture);
void CaptureSamplerParameterIuivOES_param(const State &glState,
                                          SamplerID samplerPacked,
                                          SamplerParameter pnamePacked,
                                          const GLuint *param,
                                          angle::ParamCapture *paramCapture);
void CaptureTexParameterIivOES_params(const State &glState,
                                      TextureType targetPacked,
                                      GLenum pname,
                                      const GLint *params,
                                      angle::ParamCapture *paramCapture);
void CaptureTexParameterIuivOES_params(const State &glState,
                                       TextureType targetPacked,
                                       GLenum pname,
                                       const GLuint *params,
                                       angle::ParamCapture *paramCapture);
void CaptureGetTexGenfvOES_params(const State &glState,
                                  GLenum coord,
                                  GLenum pname,
                                  GLfloat *params,
                                  angle::ParamCapture *paramCapture);
void CaptureGetTexGenivOES_params(const State &glState,
                                  GLenum coord,
                                  GLenum pname,
                                  GLint *params,
                                  angle::ParamCapture *paramCapture);
void CaptureGetTexGenxvOES_params(const State &glState,
                                  GLenum coord,
                                  GLenum pname,
                                  GLfixed *params,
                                  angle::ParamCapture *paramCapture);
void CaptureTexGenfvOES_params(const State &glState,
                               GLenum coord,
                               GLenum pname,
                               const GLfloat *params,
                               angle::ParamCapture *paramCapture);
void CaptureTexGenivOES_params(const State &glState,
                               GLenum coord,
                               GLenum pname,
                               const GLint *params,
                               angle::ParamCapture *paramCapture);
void CaptureTexGenxvOES_params(const State &glState,
                               GLenum coord,
                               GLenum pname,
                               const GLfixed *params,
                               angle::ParamCapture *paramCapture);
void CaptureDeleteVertexArraysOES_arraysPacked(const State &glState,
                                               GLsizei n,
                                               const VertexArrayID *arraysPacked,
                                               angle::ParamCapture *paramCapture);
void CaptureGenVertexArraysOES_arraysPacked(const State &glState,
                                            GLsizei n,
                                            VertexArrayID *arraysPacked,
                                            angle::ParamCapture *paramCapture);
void CaptureFramebufferFoveationConfigQCOM_providedFeatures(const State &glState,
                                                            FramebufferID framebufferPacked,
                                                            GLuint numLayers,
                                                            GLuint focalPointsPerLayer,
                                                            GLuint requestedFeatures,
                                                            GLuint *providedFeatures,
                                                            angle::ParamCapture *paramCapture);
}  // namespace gl

#endif  // LIBANGLE_CAPTURE_GLES_EXT_AUTOGEN_H_
