Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

13 files changed, 12326 insertions, 0 deletions

diff --git a/gfx/angle/checkout/src/libANGLE/capture/FrameCapture.h b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture.h
new file mode 100644
index 0000000000..aa25fbfdc0
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture.h
@@ -0,0 +1,672 @@
+
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// FrameCapture.h:
+//   ANGLE Frame capture inteface.
+//
+
+#ifndef LIBANGLE_FRAME_CAPTURE_H_
+#define LIBANGLE_FRAME_CAPTURE_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/angletypes.h"
+#include "libANGLE/capture/frame_capture_utils_autogen.h"
+#include "libANGLE/entry_points_utils.h"
+
+namespace gl
+{
+enum class GLenumGroup;
+}
+
+namespace angle
+{
+
+using ParamData = std::vector<std::vector<uint8_t>>;
+struct ParamCapture : angle::NonCopyable
+{
+    ParamCapture();
+    ParamCapture(const char *nameIn, ParamType typeIn);
+    ~ParamCapture();
+
+    ParamCapture(ParamCapture &&other);
+    ParamCapture &operator=(ParamCapture &&other);
+
+    std::string name;
+    ParamType type;
+    ParamValue value;
+    gl::GLenumGroup enumGroup;  // only used for param type GLenum, GLboolean and GLbitfield
+    ParamData data;
+    int arrayClientPointerIndex = -1;
+    size_t readBufferSizeBytes  = 0;
+};
+
+class ParamBuffer final : angle::NonCopyable
+{
+  public:
+    ParamBuffer();
+    ~ParamBuffer();
+
+    ParamBuffer(ParamBuffer &&other);
+    ParamBuffer &operator=(ParamBuffer &&other);
+
+    template <typename T>
+    void addValueParam(const char *paramName, ParamType paramType, T paramValue);
+    template <typename T>
+    void addEnumParam(const char *paramName,
+                      gl::GLenumGroup enumGroup,
+                      ParamType paramType,
+                      T paramValue);
+
+    ParamCapture &getParam(const char *paramName, ParamType paramType, int index);
+    const ParamCapture &getParam(const char *paramName, ParamType paramType, int index) const;
+    ParamCapture &getParamFlexName(const char *paramName1,
+                                   const char *paramName2,
+                                   ParamType paramType,
+                                   int index);
+    const ParamCapture &getParamFlexName(const char *paramName1,
+                                         const char *paramName2,
+                                         ParamType paramType,
+                                         int index) const;
+    const ParamCapture &getReturnValue() const { return mReturnValueCapture; }
+
+    void addParam(ParamCapture &&param);
+    void addReturnValue(ParamCapture &&returnValue);
+    bool hasClientArrayData() const { return mClientArrayDataParam != -1; }
+    ParamCapture &getClientArrayPointerParameter();
+    size_t getReadBufferSize() const { return mReadBufferSize; }
+
+    const std::vector<ParamCapture> &getParamCaptures() const { return mParamCaptures; }
+
+    // These helpers allow us to track the ID of the buffer that was active when
+    // MapBufferRange was called.  We'll use it during replay to track the
+    // buffer's contents, as they can be modified by the host.
+    void setMappedBufferID(gl::BufferID bufferID) { mMappedBufferID = bufferID; }
+    gl::BufferID getMappedBufferID() const { return mMappedBufferID; }
+
+  private:
+    std::vector<ParamCapture> mParamCaptures;
+    ParamCapture mReturnValueCapture;
+    int mClientArrayDataParam = -1;
+    size_t mReadBufferSize    = 0;
+    gl::BufferID mMappedBufferID;
+};
+
+struct CallCapture
+{
+    CallCapture(EntryPoint entryPointIn, ParamBuffer &&paramsIn);
+    CallCapture(const std::string &customFunctionNameIn, ParamBuffer &&paramsIn);
+    ~CallCapture();
+
+    CallCapture(CallCapture &&other);
+    CallCapture &operator=(CallCapture &&other);
+
+    const char *name() const;
+
+    EntryPoint entryPoint;
+    std::string customFunctionName;
+    ParamBuffer params;
+};
+
+class ReplayContext
+{
+  public:
+    ReplayContext(size_t readBufferSizebytes, const gl::AttribArray<size_t> &clientArraysSizebytes);
+    ~ReplayContext();
+
+    template <typename T>
+    T getReadBufferPointer(const ParamCapture &param)
+    {
+        ASSERT(param.readBufferSizeBytes > 0);
+        ASSERT(mReadBuffer.size() >= param.readBufferSizeBytes);
+        return reinterpret_cast<T>(mReadBuffer.data());
+    }
+    template <typename T>
+    T getAsConstPointer(const ParamCapture &param)
+    {
+        if (param.arrayClientPointerIndex != -1)
+        {
+            return reinterpret_cast<T>(mClientArraysBuffer[param.arrayClientPointerIndex].data());
+        }
+
+        if (!param.data.empty())
+        {
+            ASSERT(param.data.size() == 1);
+            return reinterpret_cast<T>(param.data[0].data());
+        }
+
+        return nullptr;
+    }
+
+    template <typename T>
+    T getAsPointerConstPointer(const ParamCapture &param)
+    {
+        static_assert(sizeof(typename std::remove_pointer<T>::type) == sizeof(uint8_t *),
+                      "pointer size not match!");
+
+        ASSERT(!param.data.empty());
+        mPointersBuffer.clear();
+        mPointersBuffer.reserve(param.data.size());
+        for (const std::vector<uint8_t> &data : param.data)
+        {
+            mPointersBuffer.emplace_back(data.data());
+        }
+        return reinterpret_cast<T>(mPointersBuffer.data());
+    }
+
+    gl::AttribArray<std::vector<uint8_t>> &getClientArraysBuffer() { return mClientArraysBuffer; }
+
+  private:
+    std::vector<uint8_t> mReadBuffer;
+    std::vector<const uint8_t *> mPointersBuffer;
+    gl::AttribArray<std::vector<uint8_t>> mClientArraysBuffer;
+};
+
+// Helper to use unique IDs for each local data variable.
+class DataCounters final : angle::NonCopyable
+{
+  public:
+    DataCounters();
+    ~DataCounters();
+
+    int getAndIncrement(EntryPoint entryPoint, const std::string &paramName);
+
+  private:
+    // <CallName, ParamName>
+    using Counter = std::pair<EntryPoint, std::string>;
+    std::map<Counter, int> mData;
+};
+
+constexpr int kStringsNotFound = -1;
+class StringCounters final : angle::NonCopyable
+{
+  public:
+    StringCounters();
+    ~StringCounters();
+
+    int getStringCounter(std::vector<std::string> &str);
+    void setStringCounter(std::vector<std::string> &str, int &counter);
+
+  private:
+    std::map<std::vector<std::string>, int> mStringCounterMap;
+};
+
+class DataTracker final : angle::NonCopyable
+{
+  public:
+    DataTracker();
+    ~DataTracker();
+
+    DataCounters &getCounters() { return mCounters; }
+    StringCounters &getStringCounters() { return mStringCounters; }
+
+  private:
+    DataCounters mCounters;
+    StringCounters mStringCounters;
+};
+
+using BufferSet   = std::set<gl::BufferID>;
+using BufferCalls = std::map<gl::BufferID, std::vector<CallCapture>>;
+
+// true means mapped, false means unmapped
+using BufferMapStatusMap = std::map<gl::BufferID, bool>;
+
+using FenceSyncSet   = std::set<GLsync>;
+using FenceSyncCalls = std::map<GLsync, std::vector<CallCapture>>;
+
+// Helper to track resource changes during the capture
+class ResourceTracker final : angle::NonCopyable
+{
+  public:
+    ResourceTracker();
+    ~ResourceTracker();
+
+    BufferCalls &getBufferRegenCalls() { return mBufferRegenCalls; }
+    BufferCalls &getBufferRestoreCalls() { return mBufferRestoreCalls; }
+    BufferCalls &getBufferMapCalls() { return mBufferMapCalls; }
+    BufferCalls &getBufferUnmapCalls() { return mBufferUnmapCalls; }
+
+    std::vector<CallCapture> &getBufferBindingCalls() { return mBufferBindingCalls; }
+
+    BufferSet &getStartingBuffers() { return mStartingBuffers; }
+    BufferSet &getNewBuffers() { return mNewBuffers; }
+    BufferSet &getBuffersToRegen() { return mBuffersToRegen; }
+    BufferSet &getBuffersToRestore() { return mBuffersToRestore; }
+
+    void setGennedBuffer(gl::BufferID id);
+    void setDeletedBuffer(gl::BufferID id);
+    void setBufferModified(gl::BufferID id);
+    void setBufferMapped(gl::BufferID id);
+    void setBufferUnmapped(gl::BufferID id);
+
+    const bool &getStartingBuffersMappedCurrent(gl::BufferID id)
+    {
+        return mStartingBuffersMappedCurrent[id];
+    }
+    const bool &getStartingBuffersMappedInitial(gl::BufferID id)
+    {
+        return mStartingBuffersMappedInitial[id];
+    }
+    void setStartingBufferMapped(gl::BufferID id, bool mapped)
+    {
+        // Track the current state (which will change throughout the trace)
+        mStartingBuffersMappedCurrent[id] = mapped;
+
+        // And the initial state, to compare during frame loop reset
+        mStartingBuffersMappedInitial[id] = mapped;
+    }
+
+    void onShaderProgramAccess(gl::ShaderProgramID shaderProgramID);
+    uint32_t getMaxShaderPrograms() const { return mMaxShaderPrograms; }
+
+    FenceSyncSet &getStartingFenceSyncs() { return mStartingFenceSyncs; }
+    FenceSyncCalls &getFenceSyncRegenCalls() { return mFenceSyncRegenCalls; }
+    FenceSyncSet &getFenceSyncsToRegen() { return mFenceSyncsToRegen; }
+    void setDeletedFenceSync(GLsync sync);
+
+  private:
+    // Buffer regen calls will delete and gen a buffer
+    BufferCalls mBufferRegenCalls;
+    // Buffer restore calls will restore the contents of a buffer
+    BufferCalls mBufferRestoreCalls;
+    // Buffer map calls will map a buffer with correct offset, length, and access flags
+    BufferCalls mBufferMapCalls;
+    // Buffer unmap calls will bind and unmap a given buffer
+    BufferCalls mBufferUnmapCalls;
+
+    // Buffer binding calls to restore bindings recorded during MEC
+    std::vector<CallCapture> mBufferBindingCalls;
+
+    // Starting buffers include all the buffers created during setup for MEC
+    BufferSet mStartingBuffers;
+    // New buffers are those generated while capturing
+    BufferSet mNewBuffers;
+    // Buffers to regen are a list of starting buffers that need to be deleted and genned
+    BufferSet mBuffersToRegen;
+    // Buffers to restore include any starting buffers with contents modified during the run
+    BufferSet mBuffersToRestore;
+
+    // Whether a given buffer was mapped at the start of the trace
+    BufferMapStatusMap mStartingBuffersMappedInitial;
+    // The status of buffer mapping throughout the trace, modified with each Map/Unmap call
+    BufferMapStatusMap mStartingBuffersMappedCurrent;
+
+    // Maximum accessed shader program ID.
+    uint32_t mMaxShaderPrograms = 0;
+
+    // Fence sync objects created during MEC setup
+    FenceSyncSet mStartingFenceSyncs;
+    // Fence sync regen calls will create a fence sync objects
+    FenceSyncCalls mFenceSyncRegenCalls;
+    // Fence syncs to regen are a list of starting fence sync objects that were deleted and need to
+    // be regen'ed.
+    FenceSyncSet mFenceSyncsToRegen;
+};
+
+// Used by the CPP replay to filter out unnecessary code.
+using HasResourceTypeMap = angle::PackedEnumBitSet<ResourceIDType>;
+
+// Map of buffer ID to offset and size used when mapped
+using BufferDataMap = std::map<gl::BufferID, std::pair<GLintptr, GLsizeiptr>>;
+
+// A dictionary of sources indexed by shader type.
+using ProgramSources = gl::ShaderMap<std::string>;
+
+// Maps from IDs to sources.
+using ShaderSourceMap  = std::map<gl::ShaderProgramID, std::string>;
+using ProgramSourceMap = std::map<gl::ShaderProgramID, ProgramSources>;
+
+// Map from textureID to level and data
+using TextureLevels       = std::map<GLint, std::vector<uint8_t>>;
+using TextureLevelDataMap = std::map<gl::TextureID, TextureLevels>;
+
+// Map from ContextID to surface dimensions
+using SurfaceDimensions = std::map<gl::ContextID, gl::Extents>;
+
+class FrameCapture final : angle::NonCopyable
+{
+  public:
+    FrameCapture();
+    ~FrameCapture();
+
+    void captureCall(const gl::Context *context, CallCapture &&call, bool isCallValid);
+    void checkForCaptureTrigger();
+    void onEndFrame(const gl::Context *context);
+    void onDestroyContext(const gl::Context *context);
+    void onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface);
+    bool enabled() const { return mEnabled; }
+
+    bool isCapturing() const;
+    void replay(gl::Context *context);
+    uint32_t getFrameCount() const;
+
+    // Returns a frame index starting from "1" as the first frame.
+    uint32_t getReplayFrameIndex() const;
+
+    void trackBufferMapping(CallCapture *call,
+                            gl::BufferID id,
+                            GLintptr offset,
+                            GLsizeiptr length,
+                            bool writable);
+
+    ResourceTracker &getResouceTracker() { return mResourceTracker; }
+
+  private:
+    void captureClientArraySnapshot(const gl::Context *context,
+                                    size_t vertexCount,
+                                    size_t instanceCount);
+    void captureMappedBufferSnapshot(const gl::Context *context, const CallCapture &call);
+
+    void copyCompressedTextureData(const gl::Context *context, const CallCapture &call);
+    void captureCompressedTextureData(const gl::Context *context, const CallCapture &call);
+
+    void reset();
+    void maybeOverrideEntryPoint(const gl::Context *context, CallCapture &call);
+    void maybeCapturePreCallUpdates(const gl::Context *context, CallCapture &call);
+    void maybeCapturePostCallUpdates(const gl::Context *context);
+    void maybeCaptureDrawArraysClientData(const gl::Context *context,
+                                          CallCapture &call,
+                                          size_t instanceCount);
+    void maybeCaptureDrawElementsClientData(const gl::Context *context,
+                                            CallCapture &call,
+                                            size_t instanceCount);
+
+    static void ReplayCall(gl::Context *context,
+                           ReplayContext *replayContext,
+                           const CallCapture &call);
+
+    void setCaptureActive() { mCaptureActive = true; }
+    void setCaptureInactive() { mCaptureActive = false; }
+    bool isCaptureActive() { return mCaptureActive; }
+
+    std::vector<CallCapture> mSetupCalls;
+    std::vector<CallCapture> mFrameCalls;
+
+    // We save one large buffer of binary data for the whole CPP replay.
+    // This simplifies a lot of file management.
+    std::vector<uint8_t> mBinaryData;
+
+    bool mEnabled = false;
+    bool mSerializeStateEnabled;
+    std::string mOutDirectory;
+    std::string mCaptureLabel;
+    bool mCompression;
+    gl::AttribArray<int> mClientVertexArrayMap;
+    uint32_t mFrameIndex;
+    uint32_t mCaptureStartFrame;
+    uint32_t mCaptureEndFrame;
+    bool mIsFirstFrame   = true;
+    bool mWroteIndexFile = false;
+    SurfaceDimensions mDrawSurfaceDimensions;
+    gl::AttribArray<size_t> mClientArraySizes;
+    size_t mReadBufferSize;
+    HasResourceTypeMap mHasResourceType;
+    BufferDataMap mBufferDataMap;
+
+    ResourceTracker mResourceTracker;
+
+    // If you don't know which frame you want to start capturing at, use the capture trigger.
+    // Initialize it to the number of frames you want to capture, and then clear the value to 0 when
+    // you reach the content you want to capture. Currently only available on Android.
+    uint32_t mCaptureTrigger;
+
+    bool mCaptureActive = false;
+};
+
+// Shared class for any items that need to be tracked by FrameCapture across shared contexts
+class FrameCaptureShared final : angle::NonCopyable
+{
+  public:
+    FrameCaptureShared();
+    ~FrameCaptureShared();
+
+    const std::string &getShaderSource(gl::ShaderProgramID id) const;
+    void setShaderSource(gl::ShaderProgramID id, std::string sources);
+
+    const ProgramSources &getProgramSources(gl::ShaderProgramID id) const;
+    void setProgramSources(gl::ShaderProgramID id, ProgramSources sources);
+
+    // Load data from a previously stored texture level
+    const std::vector<uint8_t> &retrieveCachedTextureLevel(gl::TextureID id,
+                                                           gl::TextureTarget target,
+                                                           GLint level);
+
+    // Create new texture level data and copy the source into it
+    void copyCachedTextureLevel(const gl::Context *context,
+                                gl::TextureID srcID,
+                                GLint srcLevel,
+                                gl::TextureID dstID,
+                                GLint dstLevel,
+                                const CallCapture &call);
+
+    // Create the location that should be used to cache texture level data
+    std::vector<uint8_t> &getCachedTextureLevelData(gl::Texture *texture,
+                                                    gl::TextureTarget target,
+                                                    GLint level,
+                                                    EntryPoint entryPoint);
+
+    // Remove any cached texture levels on deletion
+    void deleteCachedTextureLevelData(gl::TextureID id);
+
+  private:
+    // Cache most recently compiled and linked sources.
+    ShaderSourceMap mCachedShaderSource;
+    ProgramSourceMap mCachedProgramSources;
+
+    // Cache a shadow copy of texture level data
+    TextureLevels mCachedTextureLevels;
+    TextureLevelDataMap mCachedTextureLevelData;
+};
+
+template <typename CaptureFuncT, typename... ArgsT>
+void CaptureCallToFrameCapture(CaptureFuncT captureFunc,
+                               bool isCallValid,
+                               gl::Context *context,
+                               ArgsT... captureParams)
+{
+    FrameCapture *frameCapture = context->getFrameCapture();
+    if (!frameCapture->isCapturing())
+    {
+        return;
+    }
+
+    CallCapture call = captureFunc(context->getState(), isCallValid, captureParams...);
+
+    frameCapture->captureCall(context, std::move(call), isCallValid);
+}
+
+template <typename T>
+void ParamBuffer::addValueParam(const char *paramName, ParamType paramType, T paramValue)
+{
+    ParamCapture capture(paramName, paramType);
+    InitParamValue(paramType, paramValue, &capture.value);
+    mParamCaptures.emplace_back(std::move(capture));
+}
+
+template <typename T>
+void ParamBuffer::addEnumParam(const char *paramName,
+                               gl::GLenumGroup enumGroup,
+                               ParamType paramType,
+                               T paramValue)
+{
+    ParamCapture capture(paramName, paramType);
+    InitParamValue(paramType, paramValue, &capture.value);
+    capture.enumGroup = enumGroup;
+    mParamCaptures.emplace_back(std::move(capture));
+}
+
+std::ostream &operator<<(std::ostream &os, const ParamCapture &capture);
+
+// Pointer capture helpers.
+void CaptureMemory(const void *source, size_t size, ParamCapture *paramCapture);
+void CaptureString(const GLchar *str, ParamCapture *paramCapture);
+void CaptureStringLimit(const GLchar *str, uint32_t limit, ParamCapture *paramCapture);
+void CaptureVertexPointerGLES1(const gl::State &glState,
+                               gl::ClientVertexArrayType type,
+                               const void *pointer,
+                               ParamCapture *paramCapture);
+
+gl::Program *GetProgramForCapture(const gl::State &glState, gl::ShaderProgramID handle);
+
+// For GetIntegerv, GetFloatv, etc.
+void CaptureGetParameter(const gl::State &glState,
+                         GLenum pname,
+                         size_t typeSize,
+                         ParamCapture *paramCapture);
+
+void CaptureGetActiveUniformBlockivParameters(const gl::State &glState,
+                                              gl::ShaderProgramID handle,
+                                              gl::UniformBlockIndex uniformBlockIndex,
+                                              GLenum pname,
+                                              ParamCapture *paramCapture);
+
+template <typename T>
+void CaptureClearBufferValue(GLenum buffer, const T *value, ParamCapture *paramCapture)
+{
+    // Per the spec, color buffers have a vec4, the rest a single value
+    uint32_t valueSize = (buffer == GL_COLOR) ? 4 : 1;
+    CaptureMemory(value, valueSize * sizeof(T), paramCapture);
+}
+
+void CaptureGenHandlesImpl(GLsizei n, GLuint *handles, ParamCapture *paramCapture);
+
+template <typename T>
+void CaptureGenHandles(GLsizei n, T *handles, ParamCapture *paramCapture)
+{
+    CaptureGenHandlesImpl(n, reinterpret_cast<GLuint *>(handles), paramCapture);
+}
+
+void CaptureShaderStrings(GLsizei count,
+                          const GLchar *const *strings,
+                          const GLint *length,
+                          ParamCapture *paramCapture);
+
+template <ParamType ParamT, typename T>
+void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  GLboolean value);
+
+template <>
+void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os,
+                                                         const CallCapture &call,
+                                                         const void *value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       GLDEBUGPROCKHR value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os,
+                                                    const CallCapture &call,
+                                                    GLDEBUGPROC value);
+
+template <>
+void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os,
+                                                 const CallCapture &call,
+                                                 gl::BufferID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::FenceNVID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os,
+                                                      const CallCapture &call,
+                                                      gl::FramebufferID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       gl::MemoryObjectID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os,
+                                                          const CallCapture &call,
+                                                          gl::ProgramPipelineID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os,
+                                                const CallCapture &call,
+                                                gl::QueryID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       gl::RenderbufferID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::SamplerID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os,
+                                                    const CallCapture &call,
+                                                    gl::SemaphoreID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os,
+                                                        const CallCapture &call,
+                                                        gl::ShaderProgramID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::TextureID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os,
+                                                            const CallCapture &call,
+                                                            gl::TransformFeedbackID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os,
+                                                      const CallCapture &call,
+                                                      gl::VertexArrayID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os,
+                                                        const CallCapture &call,
+                                                        gl::UniformLocation value);
+
+template <>
+void WriteParamValueReplay<ParamType::TUniformBlockIndex>(std::ostream &os,
+                                                          const CallCapture &call,
+                                                          gl::UniformBlockIndex value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLsync>(std::ostream &os,
+                                               const CallCapture &call,
+                                               GLsync value);
+
+// General fallback for any unspecific type.
+template <ParamType ParamT, typename T>
+void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value)
+{
+    os << value;
+}
+}  // namespace angle
+
+template <typename T>
+void CaptureTextureAndSamplerParameter_params(GLenum pname,
+                                              const T *param,
+                                              angle::ParamCapture *paramCapture)
+{
+    if (pname == GL_TEXTURE_BORDER_COLOR)
+    {
+        CaptureMemory(param, sizeof(T) * 4, paramCapture);
+    }
+    else
+    {
+        CaptureMemory(param, sizeof(T), paramCapture);
+    }
+}
+
+#endif  // LIBANGLE_FRAME_CAPTURE_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/FrameCapture_mock.cpp b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture_mock.cpp
new file mode 100644
index 0000000000..cdb48a1812
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture_mock.cpp
@@ -0,0 +1,33 @@
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// FrameCapture_mock.cpp:
+//   ANGLE mock Frame capture implementation.
+//
+
+#include "libANGLE/capture/FrameCapture.h"
+
+#if ANGLE_CAPTURE_ENABLED
+#    error Frame capture must be disabled to include this file.
+#endif  // ANGLE_CAPTURE_ENABLED
+
+namespace angle
+{
+CallCapture::~CallCapture() {}
+ParamBuffer::~ParamBuffer() {}
+ParamCapture::~ParamCapture() {}
+ResourceTracker::ResourceTracker() {}
+ResourceTracker::~ResourceTracker() {}
+
+FrameCapture::FrameCapture() {}
+FrameCapture::~FrameCapture() {}
+void FrameCapture::onEndFrame(const gl::Context *context) {}
+void FrameCapture::onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface) {}
+void FrameCapture::onDestroyContext(const gl::Context *context) {}
+void FrameCapture::replay(gl::Context *context) {}
+
+FrameCaptureShared::FrameCaptureShared() {}
+FrameCaptureShared::~FrameCaptureShared() {}
+}  // namespace angle
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_1_0_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_1_0_autogen.h
new file mode 100644
index 0000000000..009ddb9977
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_1_0_autogen.h
@@ -0,0 +1,582 @@
+// 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_1_0_autogen.h:
+//   Capture functions for the OpenGL ES 1.0 entry points.
+
+#ifndef LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+angle::CallCapture CaptureAlphaFunc(const State &glState,
+                                    bool isCallValid,
+                                    AlphaTestFunc funcPacked,
+                                    GLfloat ref);
+angle::CallCapture CaptureAlphaFuncx(const State &glState,
+                                     bool isCallValid,
+                                     AlphaTestFunc funcPacked,
+                                     GLfixed ref);
+angle::CallCapture CaptureClearColorx(const State &glState,
+                                      bool isCallValid,
+                                      GLfixed red,
+                                      GLfixed green,
+                                      GLfixed blue,
+                                      GLfixed alpha);
+angle::CallCapture CaptureClearDepthx(const State &glState, bool isCallValid, GLfixed depth);
+angle::CallCapture CaptureClientActiveTexture(const State &glState,
+                                              bool isCallValid,
+                                              GLenum texture);
+angle::CallCapture CaptureClipPlanef(const State &glState,
+                                     bool isCallValid,
+                                     GLenum p,
+                                     const GLfloat *eqn);
+angle::CallCapture CaptureClipPlanex(const State &glState,
+                                     bool isCallValid,
+                                     GLenum plane,
+                                     const GLfixed *equation);
+angle::CallCapture CaptureColor4f(const State &glState,
+                                  bool isCallValid,
+                                  GLfloat red,
+                                  GLfloat green,
+                                  GLfloat blue,
+                                  GLfloat alpha);
+angle::CallCapture CaptureColor4ub(const State &glState,
+                                   bool isCallValid,
+                                   GLubyte red,
+                                   GLubyte green,
+                                   GLubyte blue,
+                                   GLubyte alpha);
+angle::CallCapture CaptureColor4x(const State &glState,
+                                  bool isCallValid,
+                                  GLfixed red,
+                                  GLfixed green,
+                                  GLfixed blue,
+                                  GLfixed alpha);
+angle::CallCapture CaptureColorPointer(const State &glState,
+                                       bool isCallValid,
+                                       GLint size,
+                                       VertexAttribType typePacked,
+                                       GLsizei stride,
+                                       const void *pointer);
+angle::CallCapture CaptureDepthRangex(const State &glState, bool isCallValid, GLfixed n, GLfixed f);
+angle::CallCapture CaptureDisableClientState(const State &glState,
+                                             bool isCallValid,
+                                             ClientVertexArrayType arrayPacked);
+angle::CallCapture CaptureEnableClientState(const State &glState,
+                                            bool isCallValid,
+                                            ClientVertexArrayType arrayPacked);
+angle::CallCapture CaptureFogf(const State &glState, bool isCallValid, GLenum pname, GLfloat param);
+angle::CallCapture CaptureFogfv(const State &glState,
+                                bool isCallValid,
+                                GLenum pname,
+                                const GLfloat *params);
+angle::CallCapture CaptureFogx(const State &glState, bool isCallValid, GLenum pname, GLfixed param);
+angle::CallCapture CaptureFogxv(const State &glState,
+                                bool isCallValid,
+                                GLenum pname,
+                                const GLfixed *param);
+angle::CallCapture CaptureFrustumf(const State &glState,
+                                   bool isCallValid,
+                                   GLfloat l,
+                                   GLfloat r,
+                                   GLfloat b,
+                                   GLfloat t,
+                                   GLfloat n,
+                                   GLfloat f);
+angle::CallCapture CaptureFrustumx(const State &glState,
+                                   bool isCallValid,
+                                   GLfixed l,
+                                   GLfixed r,
+                                   GLfixed b,
+                                   GLfixed t,
+                                   GLfixed n,
+                                   GLfixed f);
+angle::CallCapture CaptureGetClipPlanef(const State &glState,
+                                        bool isCallValid,
+                                        GLenum plane,
+                                        GLfloat *equation);
+angle::CallCapture CaptureGetClipPlanex(const State &glState,
+                                        bool isCallValid,
+                                        GLenum plane,
+                                        GLfixed *equation);
+angle::CallCapture CaptureGetFixedv(const State &glState,
+                                    bool isCallValid,
+                                    GLenum pname,
+                                    GLfixed *params);
+angle::CallCapture CaptureGetLightfv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum light,
+                                     LightParameter pnamePacked,
+                                     GLfloat *params);
+angle::CallCapture CaptureGetLightxv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum light,
+                                     LightParameter pnamePacked,
+                                     GLfixed *params);
+angle::CallCapture CaptureGetMaterialfv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum face,
+                                        MaterialParameter pnamePacked,
+                                        GLfloat *params);
+angle::CallCapture CaptureGetMaterialxv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum face,
+                                        MaterialParameter pnamePacked,
+                                        GLfixed *params);
+angle::CallCapture CaptureGetTexEnvfv(const State &glState,
+                                      bool isCallValid,
+                                      TextureEnvTarget targetPacked,
+                                      TextureEnvParameter pnamePacked,
+                                      GLfloat *params);
+angle::CallCapture CaptureGetTexEnviv(const State &glState,
+                                      bool isCallValid,
+                                      TextureEnvTarget targetPacked,
+                                      TextureEnvParameter pnamePacked,
+                                      GLint *params);
+angle::CallCapture CaptureGetTexEnvxv(const State &glState,
+                                      bool isCallValid,
+                                      TextureEnvTarget targetPacked,
+                                      TextureEnvParameter pnamePacked,
+                                      GLfixed *params);
+angle::CallCapture CaptureGetTexParameterxv(const State &glState,
+                                            bool isCallValid,
+                                            TextureType targetPacked,
+                                            GLenum pname,
+                                            GLfixed *params);
+angle::CallCapture CaptureLightModelf(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      GLfloat param);
+angle::CallCapture CaptureLightModelfv(const State &glState,
+                                       bool isCallValid,
+                                       GLenum pname,
+                                       const GLfloat *params);
+angle::CallCapture CaptureLightModelx(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      GLfixed param);
+angle::CallCapture CaptureLightModelxv(const State &glState,
+                                       bool isCallValid,
+                                       GLenum pname,
+                                       const GLfixed *param);
+angle::CallCapture CaptureLightf(const State &glState,
+                                 bool isCallValid,
+                                 GLenum light,
+                                 LightParameter pnamePacked,
+                                 GLfloat param);
+angle::CallCapture CaptureLightfv(const State &glState,
+                                  bool isCallValid,
+                                  GLenum light,
+                                  LightParameter pnamePacked,
+                                  const GLfloat *params);
+angle::CallCapture CaptureLightx(const State &glState,
+                                 bool isCallValid,
+                                 GLenum light,
+                                 LightParameter pnamePacked,
+                                 GLfixed param);
+angle::CallCapture CaptureLightxv(const State &glState,
+                                  bool isCallValid,
+                                  GLenum light,
+                                  LightParameter pnamePacked,
+                                  const GLfixed *params);
+angle::CallCapture CaptureLineWidthx(const State &glState, bool isCallValid, GLfixed width);
+angle::CallCapture CaptureLoadIdentity(const State &glState, bool isCallValid);
+angle::CallCapture CaptureLoadMatrixf(const State &glState, bool isCallValid, const GLfloat *m);
+angle::CallCapture CaptureLoadMatrixx(const State &glState, bool isCallValid, const GLfixed *m);
+angle::CallCapture CaptureLogicOp(const State &glState,
+                                  bool isCallValid,
+                                  LogicalOperation opcodePacked);
+angle::CallCapture CaptureMaterialf(const State &glState,
+                                    bool isCallValid,
+                                    GLenum face,
+                                    MaterialParameter pnamePacked,
+                                    GLfloat param);
+angle::CallCapture CaptureMaterialfv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum face,
+                                     MaterialParameter pnamePacked,
+                                     const GLfloat *params);
+angle::CallCapture CaptureMaterialx(const State &glState,
+                                    bool isCallValid,
+                                    GLenum face,
+                                    MaterialParameter pnamePacked,
+                                    GLfixed param);
+angle::CallCapture CaptureMaterialxv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum face,
+                                     MaterialParameter pnamePacked,
+                                     const GLfixed *param);
+angle::CallCapture CaptureMatrixMode(const State &glState, bool isCallValid, MatrixType modePacked);
+angle::CallCapture CaptureMultMatrixf(const State &glState, bool isCallValid, const GLfloat *m);
+angle::CallCapture CaptureMultMatrixx(const State &glState, bool isCallValid, const GLfixed *m);
+angle::CallCapture CaptureMultiTexCoord4f(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLfloat s,
+                                          GLfloat t,
+                                          GLfloat r,
+                                          GLfloat q);
+angle::CallCapture CaptureMultiTexCoord4x(const State &glState,
+                                          bool isCallValid,
+                                          GLenum texture,
+                                          GLfixed s,
+                                          GLfixed t,
+                                          GLfixed r,
+                                          GLfixed q);
+angle::CallCapture CaptureNormal3f(const State &glState,
+                                   bool isCallValid,
+                                   GLfloat nx,
+                                   GLfloat ny,
+                                   GLfloat nz);
+angle::CallCapture CaptureNormal3x(const State &glState,
+                                   bool isCallValid,
+                                   GLfixed nx,
+                                   GLfixed ny,
+                                   GLfixed nz);
+angle::CallCapture CaptureNormalPointer(const State &glState,
+                                        bool isCallValid,
+                                        VertexAttribType typePacked,
+                                        GLsizei stride,
+                                        const void *pointer);
+angle::CallCapture CaptureOrthof(const State &glState,
+                                 bool isCallValid,
+                                 GLfloat l,
+                                 GLfloat r,
+                                 GLfloat b,
+                                 GLfloat t,
+                                 GLfloat n,
+                                 GLfloat f);
+angle::CallCapture CaptureOrthox(const State &glState,
+                                 bool isCallValid,
+                                 GLfixed l,
+                                 GLfixed r,
+                                 GLfixed b,
+                                 GLfixed t,
+                                 GLfixed n,
+                                 GLfixed f);
+angle::CallCapture CapturePointParameterf(const State &glState,
+                                          bool isCallValid,
+                                          PointParameter pnamePacked,
+                                          GLfloat param);
+angle::CallCapture CapturePointParameterfv(const State &glState,
+                                           bool isCallValid,
+                                           PointParameter pnamePacked,
+                                           const GLfloat *params);
+angle::CallCapture CapturePointParameterx(const State &glState,
+                                          bool isCallValid,
+                                          PointParameter pnamePacked,
+                                          GLfixed param);
+angle::CallCapture CapturePointParameterxv(const State &glState,
+                                           bool isCallValid,
+                                           PointParameter pnamePacked,
+                                           const GLfixed *params);
+angle::CallCapture CapturePointSize(const State &glState, bool isCallValid, GLfloat size);
+angle::CallCapture CapturePointSizex(const State &glState, bool isCallValid, GLfixed size);
+angle::CallCapture CapturePolygonOffsetx(const State &glState,
+                                         bool isCallValid,
+                                         GLfixed factor,
+                                         GLfixed units);
+angle::CallCapture CapturePopMatrix(const State &glState, bool isCallValid);
+angle::CallCapture CapturePushMatrix(const State &glState, bool isCallValid);
+angle::CallCapture CaptureRotatef(const State &glState,
+                                  bool isCallValid,
+                                  GLfloat angle,
+                                  GLfloat x,
+                                  GLfloat y,
+                                  GLfloat z);
+angle::CallCapture CaptureRotatex(const State &glState,
+                                  bool isCallValid,
+                                  GLfixed angle,
+                                  GLfixed x,
+                                  GLfixed y,
+                                  GLfixed z);
+angle::CallCapture CaptureSampleCoveragex(const State &glState,
+                                          bool isCallValid,
+                                          GLclampx value,
+                                          GLboolean invert);
+angle::CallCapture CaptureScalef(const State &glState,
+                                 bool isCallValid,
+                                 GLfloat x,
+                                 GLfloat y,
+                                 GLfloat z);
+angle::CallCapture CaptureScalex(const State &glState,
+                                 bool isCallValid,
+                                 GLfixed x,
+                                 GLfixed y,
+                                 GLfixed z);
+angle::CallCapture CaptureShadeModel(const State &glState,
+                                     bool isCallValid,
+                                     ShadingModel modePacked);
+angle::CallCapture CaptureTexCoordPointer(const State &glState,
+                                          bool isCallValid,
+                                          GLint size,
+                                          VertexAttribType typePacked,
+                                          GLsizei stride,
+                                          const void *pointer);
+angle::CallCapture CaptureTexEnvf(const State &glState,
+                                  bool isCallValid,
+                                  TextureEnvTarget targetPacked,
+                                  TextureEnvParameter pnamePacked,
+                                  GLfloat param);
+angle::CallCapture CaptureTexEnvfv(const State &glState,
+                                   bool isCallValid,
+                                   TextureEnvTarget targetPacked,
+                                   TextureEnvParameter pnamePacked,
+                                   const GLfloat *params);
+angle::CallCapture CaptureTexEnvi(const State &glState,
+                                  bool isCallValid,
+                                  TextureEnvTarget targetPacked,
+                                  TextureEnvParameter pnamePacked,
+                                  GLint param);
+angle::CallCapture CaptureTexEnviv(const State &glState,
+                                   bool isCallValid,
+                                   TextureEnvTarget targetPacked,
+                                   TextureEnvParameter pnamePacked,
+                                   const GLint *params);
+angle::CallCapture CaptureTexEnvx(const State &glState,
+                                  bool isCallValid,
+                                  TextureEnvTarget targetPacked,
+                                  TextureEnvParameter pnamePacked,
+                                  GLfixed param);
+angle::CallCapture CaptureTexEnvxv(const State &glState,
+                                   bool isCallValid,
+                                   TextureEnvTarget targetPacked,
+                                   TextureEnvParameter pnamePacked,
+                                   const GLfixed *params);
+angle::CallCapture CaptureTexParameterx(const State &glState,
+                                        bool isCallValid,
+                                        TextureType targetPacked,
+                                        GLenum pname,
+                                        GLfixed param);
+angle::CallCapture CaptureTexParameterxv(const State &glState,
+                                         bool isCallValid,
+                                         TextureType targetPacked,
+                                         GLenum pname,
+                                         const GLfixed *params);
+angle::CallCapture CaptureTranslatef(const State &glState,
+                                     bool isCallValid,
+                                     GLfloat x,
+                                     GLfloat y,
+                                     GLfloat z);
+angle::CallCapture CaptureTranslatex(const State &glState,
+                                     bool isCallValid,
+                                     GLfixed x,
+                                     GLfixed y,
+                                     GLfixed z);
+angle::CallCapture CaptureVertexPointer(const State &glState,
+                                        bool isCallValid,
+                                        GLint size,
+                                        VertexAttribType typePacked,
+                                        GLsizei stride,
+                                        const void *pointer);
+
+// Parameter Captures
+
+void CaptureClipPlanef_eqn(const State &glState,
+                           bool isCallValid,
+                           GLenum p,
+                           const GLfloat *eqn,
+                           angle::ParamCapture *paramCapture);
+void CaptureClipPlanex_equation(const State &glState,
+                                bool isCallValid,
+                                GLenum plane,
+                                const GLfixed *equation,
+                                angle::ParamCapture *paramCapture);
+void CaptureColorPointer_pointer(const State &glState,
+                                 bool isCallValid,
+                                 GLint size,
+                                 VertexAttribType typePacked,
+                                 GLsizei stride,
+                                 const void *pointer,
+                                 angle::ParamCapture *paramCapture);
+void CaptureFogfv_params(const State &glState,
+                         bool isCallValid,
+                         GLenum pname,
+                         const GLfloat *params,
+                         angle::ParamCapture *paramCapture);
+void CaptureFogxv_param(const State &glState,
+                        bool isCallValid,
+                        GLenum pname,
+                        const GLfixed *param,
+                        angle::ParamCapture *paramCapture);
+void CaptureGetClipPlanef_equation(const State &glState,
+                                   bool isCallValid,
+                                   GLenum plane,
+                                   GLfloat *equation,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetClipPlanex_equation(const State &glState,
+                                   bool isCallValid,
+                                   GLenum plane,
+                                   GLfixed *equation,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetFixedv_params(const State &glState,
+                             bool isCallValid,
+                             GLenum pname,
+                             GLfixed *params,
+                             angle::ParamCapture *paramCapture);
+void CaptureGetLightfv_params(const State &glState,
+                              bool isCallValid,
+                              GLenum light,
+                              LightParameter pnamePacked,
+                              GLfloat *params,
+                              angle::ParamCapture *paramCapture);
+void CaptureGetLightxv_params(const State &glState,
+                              bool isCallValid,
+                              GLenum light,
+                              LightParameter pnamePacked,
+                              GLfixed *params,
+                              angle::ParamCapture *paramCapture);
+void CaptureGetMaterialfv_params(const State &glState,
+                                 bool isCallValid,
+                                 GLenum face,
+                                 MaterialParameter pnamePacked,
+                                 GLfloat *params,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetMaterialxv_params(const State &glState,
+                                 bool isCallValid,
+                                 GLenum face,
+                                 MaterialParameter pnamePacked,
+                                 GLfixed *params,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetTexEnvfv_params(const State &glState,
+                               bool isCallValid,
+                               TextureEnvTarget targetPacked,
+                               TextureEnvParameter pnamePacked,
+                               GLfloat *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetTexEnviv_params(const State &glState,
+                               bool isCallValid,
+                               TextureEnvTarget targetPacked,
+                               TextureEnvParameter pnamePacked,
+                               GLint *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetTexEnvxv_params(const State &glState,
+                               bool isCallValid,
+                               TextureEnvTarget targetPacked,
+                               TextureEnvParameter pnamePacked,
+                               GLfixed *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterxv_params(const State &glState,
+                                     bool isCallValid,
+                                     TextureType targetPacked,
+                                     GLenum pname,
+                                     GLfixed *params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureLightModelfv_params(const State &glState,
+                                bool isCallValid,
+                                GLenum pname,
+                                const GLfloat *params,
+                                angle::ParamCapture *paramCapture);
+void CaptureLightModelxv_param(const State &glState,
+                               bool isCallValid,
+                               GLenum pname,
+                               const GLfixed *param,
+                               angle::ParamCapture *paramCapture);
+void CaptureLightfv_params(const State &glState,
+                           bool isCallValid,
+                           GLenum light,
+                           LightParameter pnamePacked,
+                           const GLfloat *params,
+                           angle::ParamCapture *paramCapture);
+void CaptureLightxv_params(const State &glState,
+                           bool isCallValid,
+                           GLenum light,
+                           LightParameter pnamePacked,
+                           const GLfixed *params,
+                           angle::ParamCapture *paramCapture);
+void CaptureLoadMatrixf_m(const State &glState,
+                          bool isCallValid,
+                          const GLfloat *m,
+                          angle::ParamCapture *paramCapture);
+void CaptureLoadMatrixx_m(const State &glState,
+                          bool isCallValid,
+                          const GLfixed *m,
+                          angle::ParamCapture *paramCapture);
+void CaptureMaterialfv_params(const State &glState,
+                              bool isCallValid,
+                              GLenum face,
+                              MaterialParameter pnamePacked,
+                              const GLfloat *params,
+                              angle::ParamCapture *paramCapture);
+void CaptureMaterialxv_param(const State &glState,
+                             bool isCallValid,
+                             GLenum face,
+                             MaterialParameter pnamePacked,
+                             const GLfixed *param,
+                             angle::ParamCapture *paramCapture);
+void CaptureMultMatrixf_m(const State &glState,
+                          bool isCallValid,
+                          const GLfloat *m,
+                          angle::ParamCapture *paramCapture);
+void CaptureMultMatrixx_m(const State &glState,
+                          bool isCallValid,
+                          const GLfixed *m,
+                          angle::ParamCapture *paramCapture);
+void CaptureNormalPointer_pointer(const State &glState,
+                                  bool isCallValid,
+                                  VertexAttribType typePacked,
+                                  GLsizei stride,
+                                  const void *pointer,
+                                  angle::ParamCapture *paramCapture);
+void CapturePointParameterfv_params(const State &glState,
+                                    bool isCallValid,
+                                    PointParameter pnamePacked,
+                                    const GLfloat *params,
+                                    angle::ParamCapture *paramCapture);
+void CapturePointParameterxv_params(const State &glState,
+                                    bool isCallValid,
+                                    PointParameter pnamePacked,
+                                    const GLfixed *params,
+                                    angle::ParamCapture *paramCapture);
+void CaptureTexCoordPointer_pointer(const State &glState,
+                                    bool isCallValid,
+                                    GLint size,
+                                    VertexAttribType typePacked,
+                                    GLsizei stride,
+                                    const void *pointer,
+                                    angle::ParamCapture *paramCapture);
+void CaptureTexEnvfv_params(const State &glState,
+                            bool isCallValid,
+                            TextureEnvTarget targetPacked,
+                            TextureEnvParameter pnamePacked,
+                            const GLfloat *params,
+                            angle::ParamCapture *paramCapture);
+void CaptureTexEnviv_params(const State &glState,
+                            bool isCallValid,
+                            TextureEnvTarget targetPacked,
+                            TextureEnvParameter pnamePacked,
+                            const GLint *params,
+                            angle::ParamCapture *paramCapture);
+void CaptureTexEnvxv_params(const State &glState,
+                            bool isCallValid,
+                            TextureEnvTarget targetPacked,
+                            TextureEnvParameter pnamePacked,
+                            const GLfixed *params,
+                            angle::ParamCapture *paramCapture);
+void CaptureTexParameterxv_params(const State &glState,
+                                  bool isCallValid,
+                                  TextureType targetPacked,
+                                  GLenum pname,
+                                  const GLfixed *params,
+                                  angle::ParamCapture *paramCapture);
+void CaptureVertexPointer_pointer(const State &glState,
+                                  bool isCallValid,
+                                  GLint size,
+                                  VertexAttribType typePacked,
+                                  GLsizei stride,
+                                  const void *pointer,
+                                  angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_2_0_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_2_0_autogen.h
new file mode 100644
index 0000000000..45c437821a
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_2_0_autogen.h
@@ -0,0 +1,1195 @@
+// 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_2_0_autogen.h:
+//   Capture functions for the OpenGL ES 2.0 entry points.
+
+#ifndef LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+angle::CallCapture CaptureActiveTexture(const State &glState, bool isCallValid, GLenum texture);
+angle::CallCapture CaptureAttachShader(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       ShaderProgramID shaderPacked);
+angle::CallCapture CaptureBindAttribLocation(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLuint index,
+                                             const GLchar *name);
+angle::CallCapture CaptureBindBuffer(const State &glState,
+                                     bool isCallValid,
+                                     BufferBinding targetPacked,
+                                     BufferID bufferPacked);
+angle::CallCapture CaptureBindFramebuffer(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          FramebufferID framebufferPacked);
+angle::CallCapture CaptureBindRenderbuffer(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           RenderbufferID renderbufferPacked);
+angle::CallCapture CaptureBindTexture(const State &glState,
+                                      bool isCallValid,
+                                      TextureType targetPacked,
+                                      TextureID texturePacked);
+angle::CallCapture CaptureBlendColor(const State &glState,
+                                     bool isCallValid,
+                                     GLfloat red,
+                                     GLfloat green,
+                                     GLfloat blue,
+                                     GLfloat alpha);
+angle::CallCapture CaptureBlendEquation(const State &glState, bool isCallValid, GLenum mode);
+angle::CallCapture CaptureBlendEquationSeparate(const State &glState,
+                                                bool isCallValid,
+                                                GLenum modeRGB,
+                                                GLenum modeAlpha);
+angle::CallCapture CaptureBlendFunc(const State &glState,
+                                    bool isCallValid,
+                                    GLenum sfactor,
+                                    GLenum dfactor);
+angle::CallCapture CaptureBlendFuncSeparate(const State &glState,
+                                            bool isCallValid,
+                                            GLenum sfactorRGB,
+                                            GLenum dfactorRGB,
+                                            GLenum sfactorAlpha,
+                                            GLenum dfactorAlpha);
+angle::CallCapture CaptureBufferData(const State &glState,
+                                     bool isCallValid,
+                                     BufferBinding targetPacked,
+                                     GLsizeiptr size,
+                                     const void *data,
+                                     BufferUsage usagePacked);
+angle::CallCapture CaptureBufferSubData(const State &glState,
+                                        bool isCallValid,
+                                        BufferBinding targetPacked,
+                                        GLintptr offset,
+                                        GLsizeiptr size,
+                                        const void *data);
+angle::CallCapture CaptureCheckFramebufferStatus(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum target,
+                                                 GLenum returnValue);
+angle::CallCapture CaptureClear(const State &glState, bool isCallValid, GLbitfield mask);
+angle::CallCapture CaptureClearColor(const State &glState,
+                                     bool isCallValid,
+                                     GLfloat red,
+                                     GLfloat green,
+                                     GLfloat blue,
+                                     GLfloat alpha);
+angle::CallCapture CaptureClearDepthf(const State &glState, bool isCallValid, GLfloat d);
+angle::CallCapture CaptureClearStencil(const State &glState, bool isCallValid, GLint s);
+angle::CallCapture CaptureColorMask(const State &glState,
+                                    bool isCallValid,
+                                    GLboolean red,
+                                    GLboolean green,
+                                    GLboolean blue,
+                                    GLboolean alpha);
+angle::CallCapture CaptureCompileShader(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID shaderPacked);
+angle::CallCapture CaptureCompressedTexImage2D(const State &glState,
+                                               bool isCallValid,
+                                               TextureTarget targetPacked,
+                                               GLint level,
+                                               GLenum internalformat,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLint border,
+                                               GLsizei imageSize,
+                                               const void *data);
+angle::CallCapture CaptureCompressedTexSubImage2D(const State &glState,
+                                                  bool isCallValid,
+                                                  TextureTarget targetPacked,
+                                                  GLint level,
+                                                  GLint xoffset,
+                                                  GLint yoffset,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLenum format,
+                                                  GLsizei imageSize,
+                                                  const void *data);
+angle::CallCapture CaptureCopyTexImage2D(const State &glState,
+                                         bool isCallValid,
+                                         TextureTarget targetPacked,
+                                         GLint level,
+                                         GLenum internalformat,
+                                         GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLint border);
+angle::CallCapture CaptureCopyTexSubImage2D(const State &glState,
+                                            bool isCallValid,
+                                            TextureTarget targetPacked,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height);
+angle::CallCapture CaptureCreateProgram(const State &glState, bool isCallValid, GLuint returnValue);
+angle::CallCapture CaptureCreateShader(const State &glState,
+                                       bool isCallValid,
+                                       ShaderType typePacked,
+                                       GLuint returnValue);
+angle::CallCapture CaptureCullFace(const State &glState, bool isCallValid, CullFaceMode modePacked);
+angle::CallCapture CaptureDeleteBuffers(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        const BufferID *buffersPacked);
+angle::CallCapture CaptureDeleteFramebuffers(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             const FramebufferID *framebuffersPacked);
+angle::CallCapture CaptureDeleteProgram(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked);
+angle::CallCapture CaptureDeleteRenderbuffers(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              const RenderbufferID *renderbuffersPacked);
+angle::CallCapture CaptureDeleteShader(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID shaderPacked);
+angle::CallCapture CaptureDeleteTextures(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei n,
+                                         const TextureID *texturesPacked);
+angle::CallCapture CaptureDepthFunc(const State &glState, bool isCallValid, GLenum func);
+angle::CallCapture CaptureDepthMask(const State &glState, bool isCallValid, GLboolean flag);
+angle::CallCapture CaptureDepthRangef(const State &glState, bool isCallValid, GLfloat n, GLfloat f);
+angle::CallCapture CaptureDetachShader(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       ShaderProgramID shaderPacked);
+angle::CallCapture CaptureDisable(const State &glState, bool isCallValid, GLenum cap);
+angle::CallCapture CaptureDisableVertexAttribArray(const State &glState,
+                                                   bool isCallValid,
+                                                   GLuint index);
+angle::CallCapture CaptureDrawArrays(const State &glState,
+                                     bool isCallValid,
+                                     PrimitiveMode modePacked,
+                                     GLint first,
+                                     GLsizei count);
+angle::CallCapture CaptureDrawElements(const State &glState,
+                                       bool isCallValid,
+                                       PrimitiveMode modePacked,
+                                       GLsizei count,
+                                       DrawElementsType typePacked,
+                                       const void *indices);
+angle::CallCapture CaptureEnable(const State &glState, bool isCallValid, GLenum cap);
+angle::CallCapture CaptureEnableVertexAttribArray(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint index);
+angle::CallCapture CaptureFinish(const State &glState, bool isCallValid);
+angle::CallCapture CaptureFlush(const State &glState, bool isCallValid);
+angle::CallCapture CaptureFramebufferRenderbuffer(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum target,
+                                                  GLenum attachment,
+                                                  GLenum renderbuffertarget,
+                                                  RenderbufferID renderbufferPacked);
+angle::CallCapture CaptureFramebufferTexture2D(const State &glState,
+                                               bool isCallValid,
+                                               GLenum target,
+                                               GLenum attachment,
+                                               TextureTarget textargetPacked,
+                                               TextureID texturePacked,
+                                               GLint level);
+angle::CallCapture CaptureFrontFace(const State &glState, bool isCallValid, GLenum mode);
+angle::CallCapture CaptureGenBuffers(const State &glState,
+                                     bool isCallValid,
+                                     GLsizei n,
+                                     BufferID *buffersPacked);
+angle::CallCapture CaptureGenFramebuffers(const State &glState,
+                                          bool isCallValid,
+                                          GLsizei n,
+                                          FramebufferID *framebuffersPacked);
+angle::CallCapture CaptureGenRenderbuffers(const State &glState,
+                                           bool isCallValid,
+                                           GLsizei n,
+                                           RenderbufferID *renderbuffersPacked);
+angle::CallCapture CaptureGenTextures(const State &glState,
+                                      bool isCallValid,
+                                      GLsizei n,
+                                      TextureID *texturesPacked);
+angle::CallCapture CaptureGenerateMipmap(const State &glState,
+                                         bool isCallValid,
+                                         TextureType targetPacked);
+angle::CallCapture CaptureGetActiveAttrib(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          GLuint index,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint *size,
+                                          GLenum *type,
+                                          GLchar *name);
+angle::CallCapture CaptureGetActiveUniform(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           GLuint index,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLint *size,
+                                           GLenum *type,
+                                           GLchar *name);
+angle::CallCapture CaptureGetAttachedShaders(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLsizei maxCount,
+                                             GLsizei *count,
+                                             ShaderProgramID *shadersPacked);
+angle::CallCapture CaptureGetAttribLocation(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            const GLchar *name,
+                                            GLint returnValue);
+angle::CallCapture CaptureGetBooleanv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      GLboolean *data);
+angle::CallCapture CaptureGetBufferParameteriv(const State &glState,
+                                               bool isCallValid,
+                                               BufferBinding targetPacked,
+                                               GLenum pname,
+                                               GLint *params);
+angle::CallCapture CaptureGetError(const State &glState, bool isCallValid, GLenum returnValue);
+angle::CallCapture CaptureGetFloatv(const State &glState,
+                                    bool isCallValid,
+                                    GLenum pname,
+                                    GLfloat *data);
+angle::CallCapture CaptureGetFramebufferAttachmentParameteriv(const State &glState,
+                                                              bool isCallValid,
+                                                              GLenum target,
+                                                              GLenum attachment,
+                                                              GLenum pname,
+                                                              GLint *params);
+angle::CallCapture CaptureGetIntegerv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      GLint *data);
+angle::CallCapture CaptureGetProgramInfoLog(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLchar *infoLog);
+angle::CallCapture CaptureGetProgramiv(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       GLenum pname,
+                                       GLint *params);
+angle::CallCapture CaptureGetRenderbufferParameteriv(const State &glState,
+                                                     bool isCallValid,
+                                                     GLenum target,
+                                                     GLenum pname,
+                                                     GLint *params);
+angle::CallCapture CaptureGetShaderInfoLog(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID shaderPacked,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLchar *infoLog);
+angle::CallCapture CaptureGetShaderPrecisionFormat(const State &glState,
+                                                   bool isCallValid,
+                                                   GLenum shadertype,
+                                                   GLenum precisiontype,
+                                                   GLint *range,
+                                                   GLint *precision);
+angle::CallCapture CaptureGetShaderSource(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID shaderPacked,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLchar *source);
+angle::CallCapture CaptureGetShaderiv(const State &glState,
+                                      bool isCallValid,
+                                      ShaderProgramID shaderPacked,
+                                      GLenum pname,
+                                      GLint *params);
+angle::CallCapture CaptureGetString(const State &glState,
+                                    bool isCallValid,
+                                    GLenum name,
+                                    const GLubyte *returnValue);
+angle::CallCapture CaptureGetTexParameterfv(const State &glState,
+                                            bool isCallValid,
+                                            TextureType targetPacked,
+                                            GLenum pname,
+                                            GLfloat *params);
+angle::CallCapture CaptureGetTexParameteriv(const State &glState,
+                                            bool isCallValid,
+                                            TextureType targetPacked,
+                                            GLenum pname,
+                                            GLint *params);
+angle::CallCapture CaptureGetUniformLocation(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             const GLchar *name,
+                                             GLint returnValue);
+angle::CallCapture CaptureGetUniformfv(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLfloat *params);
+angle::CallCapture CaptureGetUniformiv(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLint *params);
+angle::CallCapture CaptureGetVertexAttribPointerv(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint index,
+                                                  GLenum pname,
+                                                  void **pointer);
+angle::CallCapture CaptureGetVertexAttribfv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLenum pname,
+                                            GLfloat *params);
+angle::CallCapture CaptureGetVertexAttribiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLenum pname,
+                                            GLint *params);
+angle::CallCapture CaptureHint(const State &glState, bool isCallValid, GLenum target, GLenum mode);
+angle::CallCapture CaptureIsBuffer(const State &glState,
+                                   bool isCallValid,
+                                   BufferID bufferPacked,
+                                   GLboolean returnValue);
+angle::CallCapture CaptureIsEnabled(const State &glState,
+                                    bool isCallValid,
+                                    GLenum cap,
+                                    GLboolean returnValue);
+angle::CallCapture CaptureIsFramebuffer(const State &glState,
+                                        bool isCallValid,
+                                        FramebufferID framebufferPacked,
+                                        GLboolean returnValue);
+angle::CallCapture CaptureIsProgram(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    GLboolean returnValue);
+angle::CallCapture CaptureIsRenderbuffer(const State &glState,
+                                         bool isCallValid,
+                                         RenderbufferID renderbufferPacked,
+                                         GLboolean returnValue);
+angle::CallCapture CaptureIsShader(const State &glState,
+                                   bool isCallValid,
+                                   ShaderProgramID shaderPacked,
+                                   GLboolean returnValue);
+angle::CallCapture CaptureIsTexture(const State &glState,
+                                    bool isCallValid,
+                                    TextureID texturePacked,
+                                    GLboolean returnValue);
+angle::CallCapture CaptureLineWidth(const State &glState, bool isCallValid, GLfloat width);
+angle::CallCapture CaptureLinkProgram(const State &glState,
+                                      bool isCallValid,
+                                      ShaderProgramID programPacked);
+angle::CallCapture CapturePixelStorei(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      GLint param);
+angle::CallCapture CapturePolygonOffset(const State &glState,
+                                        bool isCallValid,
+                                        GLfloat factor,
+                                        GLfloat units);
+angle::CallCapture CaptureReadPixels(const State &glState,
+                                     bool isCallValid,
+                                     GLint x,
+                                     GLint y,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLenum format,
+                                     GLenum type,
+                                     void *pixels);
+angle::CallCapture CaptureReleaseShaderCompiler(const State &glState, bool isCallValid);
+angle::CallCapture CaptureRenderbufferStorage(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              GLenum internalformat,
+                                              GLsizei width,
+                                              GLsizei height);
+angle::CallCapture CaptureSampleCoverage(const State &glState,
+                                         bool isCallValid,
+                                         GLfloat value,
+                                         GLboolean invert);
+angle::CallCapture CaptureScissor(const State &glState,
+                                  bool isCallValid,
+                                  GLint x,
+                                  GLint y,
+                                  GLsizei width,
+                                  GLsizei height);
+angle::CallCapture CaptureShaderBinary(const State &glState,
+                                       bool isCallValid,
+                                       GLsizei count,
+                                       const ShaderProgramID *shadersPacked,
+                                       GLenum binaryformat,
+                                       const void *binary,
+                                       GLsizei length);
+angle::CallCapture CaptureShaderSource(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID shaderPacked,
+                                       GLsizei count,
+                                       const GLchar *const *string,
+                                       const GLint *length);
+angle::CallCapture CaptureStencilFunc(const State &glState,
+                                      bool isCallValid,
+                                      GLenum func,
+                                      GLint ref,
+                                      GLuint mask);
+angle::CallCapture CaptureStencilFuncSeparate(const State &glState,
+                                              bool isCallValid,
+                                              GLenum face,
+                                              GLenum func,
+                                              GLint ref,
+                                              GLuint mask);
+angle::CallCapture CaptureStencilMask(const State &glState, bool isCallValid, GLuint mask);
+angle::CallCapture CaptureStencilMaskSeparate(const State &glState,
+                                              bool isCallValid,
+                                              GLenum face,
+                                              GLuint mask);
+angle::CallCapture CaptureStencilOp(const State &glState,
+                                    bool isCallValid,
+                                    GLenum fail,
+                                    GLenum zfail,
+                                    GLenum zpass);
+angle::CallCapture CaptureStencilOpSeparate(const State &glState,
+                                            bool isCallValid,
+                                            GLenum face,
+                                            GLenum sfail,
+                                            GLenum dpfail,
+                                            GLenum dppass);
+angle::CallCapture CaptureTexImage2D(const State &glState,
+                                     bool isCallValid,
+                                     TextureTarget targetPacked,
+                                     GLint level,
+                                     GLint internalformat,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLint border,
+                                     GLenum format,
+                                     GLenum type,
+                                     const void *pixels);
+angle::CallCapture CaptureTexParameterf(const State &glState,
+                                        bool isCallValid,
+                                        TextureType targetPacked,
+                                        GLenum pname,
+                                        GLfloat param);
+angle::CallCapture CaptureTexParameterfv(const State &glState,
+                                         bool isCallValid,
+                                         TextureType targetPacked,
+                                         GLenum pname,
+                                         const GLfloat *params);
+angle::CallCapture CaptureTexParameteri(const State &glState,
+                                        bool isCallValid,
+                                        TextureType targetPacked,
+                                        GLenum pname,
+                                        GLint param);
+angle::CallCapture CaptureTexParameteriv(const State &glState,
+                                         bool isCallValid,
+                                         TextureType targetPacked,
+                                         GLenum pname,
+                                         const GLint *params);
+angle::CallCapture CaptureTexSubImage2D(const State &glState,
+                                        bool isCallValid,
+                                        TextureTarget targetPacked,
+                                        GLint level,
+                                        GLint xoffset,
+                                        GLint yoffset,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLenum format,
+                                        GLenum type,
+                                        const void *pixels);
+angle::CallCapture CaptureUniform1f(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLfloat v0);
+angle::CallCapture CaptureUniform1fv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLfloat *value);
+angle::CallCapture CaptureUniform1i(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLint v0);
+angle::CallCapture CaptureUniform1iv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLint *value);
+angle::CallCapture CaptureUniform2f(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLfloat v0,
+                                    GLfloat v1);
+angle::CallCapture CaptureUniform2fv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLfloat *value);
+angle::CallCapture CaptureUniform2i(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLint v0,
+                                    GLint v1);
+angle::CallCapture CaptureUniform2iv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLint *value);
+angle::CallCapture CaptureUniform3f(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLfloat v0,
+                                    GLfloat v1,
+                                    GLfloat v2);
+angle::CallCapture CaptureUniform3fv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLfloat *value);
+angle::CallCapture CaptureUniform3i(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLint v0,
+                                    GLint v1,
+                                    GLint v2);
+angle::CallCapture CaptureUniform3iv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLint *value);
+angle::CallCapture CaptureUniform4f(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLfloat v0,
+                                    GLfloat v1,
+                                    GLfloat v2,
+                                    GLfloat v3);
+angle::CallCapture CaptureUniform4fv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLfloat *value);
+angle::CallCapture CaptureUniform4i(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLint v0,
+                                    GLint v1,
+                                    GLint v2,
+                                    GLint v3);
+angle::CallCapture CaptureUniform4iv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLint *value);
+angle::CallCapture CaptureUniformMatrix2fv(const State &glState,
+                                           bool isCallValid,
+                                           UniformLocation locationPacked,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value);
+angle::CallCapture CaptureUniformMatrix3fv(const State &glState,
+                                           bool isCallValid,
+                                           UniformLocation locationPacked,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value);
+angle::CallCapture CaptureUniformMatrix4fv(const State &glState,
+                                           bool isCallValid,
+                                           UniformLocation locationPacked,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value);
+angle::CallCapture CaptureUseProgram(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked);
+angle::CallCapture CaptureValidateProgram(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked);
+angle::CallCapture CaptureVertexAttrib1f(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLfloat x);
+angle::CallCapture CaptureVertexAttrib1fv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLfloat *v);
+angle::CallCapture CaptureVertexAttrib2f(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLfloat x,
+                                         GLfloat y);
+angle::CallCapture CaptureVertexAttrib2fv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLfloat *v);
+angle::CallCapture CaptureVertexAttrib3f(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLfloat x,
+                                         GLfloat y,
+                                         GLfloat z);
+angle::CallCapture CaptureVertexAttrib3fv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLfloat *v);
+angle::CallCapture CaptureVertexAttrib4f(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLfloat x,
+                                         GLfloat y,
+                                         GLfloat z,
+                                         GLfloat w);
+angle::CallCapture CaptureVertexAttrib4fv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLfloat *v);
+angle::CallCapture CaptureVertexAttribPointer(const State &glState,
+                                              bool isCallValid,
+                                              GLuint index,
+                                              GLint size,
+                                              VertexAttribType typePacked,
+                                              GLboolean normalized,
+                                              GLsizei stride,
+                                              const void *pointer);
+angle::CallCapture CaptureViewport(const State &glState,
+                                   bool isCallValid,
+                                   GLint x,
+                                   GLint y,
+                                   GLsizei width,
+                                   GLsizei height);
+
+// Parameter Captures
+
+void CaptureBindAttribLocation_name(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    GLuint index,
+                                    const GLchar *name,
+                                    angle::ParamCapture *paramCapture);
+void CaptureBufferData_data(const State &glState,
+                            bool isCallValid,
+                            BufferBinding targetPacked,
+                            GLsizeiptr size,
+                            const void *data,
+                            BufferUsage usagePacked,
+                            angle::ParamCapture *paramCapture);
+void CaptureBufferSubData_data(const State &glState,
+                               bool isCallValid,
+                               BufferBinding targetPacked,
+                               GLintptr offset,
+                               GLsizeiptr size,
+                               const void *data,
+                               angle::ParamCapture *paramCapture);
+void CaptureCompressedTexImage2D_data(const State &glState,
+                                      bool isCallValid,
+                                      TextureTarget targetPacked,
+                                      GLint level,
+                                      GLenum internalformat,
+                                      GLsizei width,
+                                      GLsizei height,
+                                      GLint border,
+                                      GLsizei imageSize,
+                                      const void *data,
+                                      angle::ParamCapture *paramCapture);
+void CaptureCompressedTexSubImage2D_data(const State &glState,
+                                         bool isCallValid,
+                                         TextureTarget targetPacked,
+                                         GLint level,
+                                         GLint xoffset,
+                                         GLint yoffset,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLenum format,
+                                         GLsizei imageSize,
+                                         const void *data,
+                                         angle::ParamCapture *paramCapture);
+void CaptureDeleteBuffers_buffersPacked(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        const BufferID *buffersPacked,
+                                        angle::ParamCapture *paramCapture);
+void CaptureDeleteFramebuffers_framebuffersPacked(const State &glState,
+                                                  bool isCallValid,
+                                                  GLsizei n,
+                                                  const FramebufferID *framebuffersPacked,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureDeleteRenderbuffers_renderbuffersPacked(const State &glState,
+                                                    bool isCallValid,
+                                                    GLsizei n,
+                                                    const RenderbufferID *renderbuffersPacked,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureDeleteTextures_texturesPacked(const State &glState,
+                                          bool isCallValid,
+                                          GLsizei n,
+                                          const TextureID *texturesPacked,
+                                          angle::ParamCapture *paramCapture);
+void CaptureDrawElements_indices(const State &glState,
+                                 bool isCallValid,
+                                 PrimitiveMode modePacked,
+                                 GLsizei count,
+                                 DrawElementsType typePacked,
+                                 const void *indices,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGenBuffers_buffersPacked(const State &glState,
+                                     bool isCallValid,
+                                     GLsizei n,
+                                     BufferID *buffersPacked,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGenFramebuffers_framebuffersPacked(const State &glState,
+                                               bool isCallValid,
+                                               GLsizei n,
+                                               FramebufferID *framebuffersPacked,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGenRenderbuffers_renderbuffersPacked(const State &glState,
+                                                 bool isCallValid,
+                                                 GLsizei n,
+                                                 RenderbufferID *renderbuffersPacked,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGenTextures_texturesPacked(const State &glState,
+                                       bool isCallValid,
+                                       GLsizei n,
+                                       TextureID *texturesPacked,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetActiveAttrib_length(const State &glState,
+                                   bool isCallValid,
+                                   ShaderProgramID programPacked,
+                                   GLuint index,
+                                   GLsizei bufSize,
+                                   GLsizei *length,
+                                   GLint *size,
+                                   GLenum *type,
+                                   GLchar *name,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetActiveAttrib_size(const State &glState,
+                                 bool isCallValid,
+                                 ShaderProgramID programPacked,
+                                 GLuint index,
+                                 GLsizei bufSize,
+                                 GLsizei *length,
+                                 GLint *size,
+                                 GLenum *type,
+                                 GLchar *name,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetActiveAttrib_type(const State &glState,
+                                 bool isCallValid,
+                                 ShaderProgramID programPacked,
+                                 GLuint index,
+                                 GLsizei bufSize,
+                                 GLsizei *length,
+                                 GLint *size,
+                                 GLenum *type,
+                                 GLchar *name,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetActiveAttrib_name(const State &glState,
+                                 bool isCallValid,
+                                 ShaderProgramID programPacked,
+                                 GLuint index,
+                                 GLsizei bufSize,
+                                 GLsizei *length,
+                                 GLint *size,
+                                 GLenum *type,
+                                 GLchar *name,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniform_length(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    GLuint index,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLint *size,
+                                    GLenum *type,
+                                    GLchar *name,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniform_size(const State &glState,
+                                  bool isCallValid,
+                                  ShaderProgramID programPacked,
+                                  GLuint index,
+                                  GLsizei bufSize,
+                                  GLsizei *length,
+                                  GLint *size,
+                                  GLenum *type,
+                                  GLchar *name,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniform_type(const State &glState,
+                                  bool isCallValid,
+                                  ShaderProgramID programPacked,
+                                  GLuint index,
+                                  GLsizei bufSize,
+                                  GLsizei *length,
+                                  GLint *size,
+                                  GLenum *type,
+                                  GLchar *name,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniform_name(const State &glState,
+                                  bool isCallValid,
+                                  ShaderProgramID programPacked,
+                                  GLuint index,
+                                  GLsizei bufSize,
+                                  GLsizei *length,
+                                  GLint *size,
+                                  GLenum *type,
+                                  GLchar *name,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetAttachedShaders_count(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     GLsizei maxCount,
+                                     GLsizei *count,
+                                     ShaderProgramID *shadersPacked,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetAttachedShaders_shadersPacked(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLsizei maxCount,
+                                             GLsizei *count,
+                                             ShaderProgramID *shadersPacked,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetAttribLocation_name(const State &glState,
+                                   bool isCallValid,
+                                   ShaderProgramID programPacked,
+                                   const GLchar *name,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetBooleanv_data(const State &glState,
+                             bool isCallValid,
+                             GLenum pname,
+                             GLboolean *data,
+                             angle::ParamCapture *paramCapture);
+void CaptureGetBufferParameteriv_params(const State &glState,
+                                        bool isCallValid,
+                                        BufferBinding targetPacked,
+                                        GLenum pname,
+                                        GLint *params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetFloatv_data(const State &glState,
+                           bool isCallValid,
+                           GLenum pname,
+                           GLfloat *data,
+                           angle::ParamCapture *paramCapture);
+void CaptureGetFramebufferAttachmentParameteriv_params(const State &glState,
+                                                       bool isCallValid,
+                                                       GLenum target,
+                                                       GLenum attachment,
+                                                       GLenum pname,
+                                                       GLint *params,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureGetIntegerv_data(const State &glState,
+                             bool isCallValid,
+                             GLenum pname,
+                             GLint *data,
+                             angle::ParamCapture *paramCapture);
+void CaptureGetProgramInfoLog_length(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     GLsizei bufSize,
+                                     GLsizei *length,
+                                     GLchar *infoLog,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetProgramInfoLog_infoLog(const State &glState,
+                                      bool isCallValid,
+                                      ShaderProgramID programPacked,
+                                      GLsizei bufSize,
+                                      GLsizei *length,
+                                      GLchar *infoLog,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGetProgramiv_params(const State &glState,
+                                bool isCallValid,
+                                ShaderProgramID programPacked,
+                                GLenum pname,
+                                GLint *params,
+                                angle::ParamCapture *paramCapture);
+void CaptureGetRenderbufferParameteriv_params(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              GLenum pname,
+                                              GLint *params,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetShaderInfoLog_length(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID shaderPacked,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLchar *infoLog,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetShaderInfoLog_infoLog(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID shaderPacked,
+                                     GLsizei bufSize,
+                                     GLsizei *length,
+                                     GLchar *infoLog,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetShaderPrecisionFormat_range(const State &glState,
+                                           bool isCallValid,
+                                           GLenum shadertype,
+                                           GLenum precisiontype,
+                                           GLint *range,
+                                           GLint *precision,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetShaderPrecisionFormat_precision(const State &glState,
+                                               bool isCallValid,
+                                               GLenum shadertype,
+                                               GLenum precisiontype,
+                                               GLint *range,
+                                               GLint *precision,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetShaderSource_length(const State &glState,
+                                   bool isCallValid,
+                                   ShaderProgramID shaderPacked,
+                                   GLsizei bufSize,
+                                   GLsizei *length,
+                                   GLchar *source,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetShaderSource_source(const State &glState,
+                                   bool isCallValid,
+                                   ShaderProgramID shaderPacked,
+                                   GLsizei bufSize,
+                                   GLsizei *length,
+                                   GLchar *source,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetShaderiv_params(const State &glState,
+                               bool isCallValid,
+                               ShaderProgramID shaderPacked,
+                               GLenum pname,
+                               GLint *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterfv_params(const State &glState,
+                                     bool isCallValid,
+                                     TextureType targetPacked,
+                                     GLenum pname,
+                                     GLfloat *params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetTexParameteriv_params(const State &glState,
+                                     bool isCallValid,
+                                     TextureType targetPacked,
+                                     GLenum pname,
+                                     GLint *params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetUniformLocation_name(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    const GLchar *name,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetUniformfv_params(const State &glState,
+                                bool isCallValid,
+                                ShaderProgramID programPacked,
+                                UniformLocation locationPacked,
+                                GLfloat *params,
+                                angle::ParamCapture *paramCapture);
+void CaptureGetUniformiv_params(const State &glState,
+                                bool isCallValid,
+                                ShaderProgramID programPacked,
+                                UniformLocation locationPacked,
+                                GLint *params,
+                                angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribPointerv_pointer(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLenum pname,
+                                            void **pointer,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribfv_params(const State &glState,
+                                     bool isCallValid,
+                                     GLuint index,
+                                     GLenum pname,
+                                     GLfloat *params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribiv_params(const State &glState,
+                                     bool isCallValid,
+                                     GLuint index,
+                                     GLenum pname,
+                                     GLint *params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureReadPixels_pixels(const State &glState,
+                              bool isCallValid,
+                              GLint x,
+                              GLint y,
+                              GLsizei width,
+                              GLsizei height,
+                              GLenum format,
+                              GLenum type,
+                              void *pixels,
+                              angle::ParamCapture *paramCapture);
+void CaptureShaderBinary_shadersPacked(const State &glState,
+                                       bool isCallValid,
+                                       GLsizei count,
+                                       const ShaderProgramID *shadersPacked,
+                                       GLenum binaryformat,
+                                       const void *binary,
+                                       GLsizei length,
+                                       angle::ParamCapture *paramCapture);
+void CaptureShaderBinary_binary(const State &glState,
+                                bool isCallValid,
+                                GLsizei count,
+                                const ShaderProgramID *shadersPacked,
+                                GLenum binaryformat,
+                                const void *binary,
+                                GLsizei length,
+                                angle::ParamCapture *paramCapture);
+void CaptureShaderSource_string(const State &glState,
+                                bool isCallValid,
+                                ShaderProgramID shaderPacked,
+                                GLsizei count,
+                                const GLchar *const *string,
+                                const GLint *length,
+                                angle::ParamCapture *paramCapture);
+void CaptureShaderSource_length(const State &glState,
+                                bool isCallValid,
+                                ShaderProgramID shaderPacked,
+                                GLsizei count,
+                                const GLchar *const *string,
+                                const GLint *length,
+                                angle::ParamCapture *paramCapture);
+void CaptureTexImage2D_pixels(const State &glState,
+                              bool isCallValid,
+                              TextureTarget targetPacked,
+                              GLint level,
+                              GLint internalformat,
+                              GLsizei width,
+                              GLsizei height,
+                              GLint border,
+                              GLenum format,
+                              GLenum type,
+                              const void *pixels,
+                              angle::ParamCapture *paramCapture);
+void CaptureTexParameterfv_params(const State &glState,
+                                  bool isCallValid,
+                                  TextureType targetPacked,
+                                  GLenum pname,
+                                  const GLfloat *params,
+                                  angle::ParamCapture *paramCapture);
+void CaptureTexParameteriv_params(const State &glState,
+                                  bool isCallValid,
+                                  TextureType targetPacked,
+                                  GLenum pname,
+                                  const GLint *params,
+                                  angle::ParamCapture *paramCapture);
+void CaptureTexSubImage2D_pixels(const State &glState,
+                                 bool isCallValid,
+                                 TextureTarget targetPacked,
+                                 GLint level,
+                                 GLint xoffset,
+                                 GLint yoffset,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void *pixels,
+                                 angle::ParamCapture *paramCapture);
+void CaptureUniform1fv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLfloat *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform1iv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLint *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform2fv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLfloat *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform2iv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLint *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform3fv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLfloat *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform3iv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLint *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform4fv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLfloat *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform4iv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLint *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix2fv_value(const State &glState,
+                                   bool isCallValid,
+                                   UniformLocation locationPacked,
+                                   GLsizei count,
+                                   GLboolean transpose,
+                                   const GLfloat *value,
+                                   angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix3fv_value(const State &glState,
+                                   bool isCallValid,
+                                   UniformLocation locationPacked,
+                                   GLsizei count,
+                                   GLboolean transpose,
+                                   const GLfloat *value,
+                                   angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix4fv_value(const State &glState,
+                                   bool isCallValid,
+                                   UniformLocation locationPacked,
+                                   GLsizei count,
+                                   GLboolean transpose,
+                                   const GLfloat *value,
+                                   angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib1fv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLfloat *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib2fv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLfloat *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib3fv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLfloat *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4fv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLfloat *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttribPointer_pointer(const State &glState,
+                                        bool isCallValid,
+                                        GLuint index,
+                                        GLint size,
+                                        VertexAttribType typePacked,
+                                        GLboolean normalized,
+                                        GLsizei stride,
+                                        const void *pointer,
+                                        angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_0_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_0_autogen.h
new file mode 100644
index 0000000000..a0442ea446
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_0_autogen.h
@@ -0,0 +1,1079 @@
+// 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_3_0_autogen.h:
+//   Capture functions for the OpenGL ES 3.0 entry points.
+
+#ifndef LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+angle::CallCapture CaptureBeginQuery(const State &glState,
+                                     bool isCallValid,
+                                     QueryType targetPacked,
+                                     QueryID idPacked);
+angle::CallCapture CaptureBeginTransformFeedback(const State &glState,
+                                                 bool isCallValid,
+                                                 PrimitiveMode primitiveModePacked);
+angle::CallCapture CaptureBindBufferBase(const State &glState,
+                                         bool isCallValid,
+                                         BufferBinding targetPacked,
+                                         GLuint index,
+                                         BufferID bufferPacked);
+angle::CallCapture CaptureBindBufferRange(const State &glState,
+                                          bool isCallValid,
+                                          BufferBinding targetPacked,
+                                          GLuint index,
+                                          BufferID bufferPacked,
+                                          GLintptr offset,
+                                          GLsizeiptr size);
+angle::CallCapture CaptureBindSampler(const State &glState,
+                                      bool isCallValid,
+                                      GLuint unit,
+                                      SamplerID samplerPacked);
+angle::CallCapture CaptureBindTransformFeedback(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                TransformFeedbackID idPacked);
+angle::CallCapture CaptureBindVertexArray(const State &glState,
+                                          bool isCallValid,
+                                          VertexArrayID arrayPacked);
+angle::CallCapture CaptureBlitFramebuffer(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);
+angle::CallCapture CaptureClearBufferfi(const State &glState,
+                                        bool isCallValid,
+                                        GLenum buffer,
+                                        GLint drawbuffer,
+                                        GLfloat depth,
+                                        GLint stencil);
+angle::CallCapture CaptureClearBufferfv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum buffer,
+                                        GLint drawbuffer,
+                                        const GLfloat *value);
+angle::CallCapture CaptureClearBufferiv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum buffer,
+                                        GLint drawbuffer,
+                                        const GLint *value);
+angle::CallCapture CaptureClearBufferuiv(const State &glState,
+                                         bool isCallValid,
+                                         GLenum buffer,
+                                         GLint drawbuffer,
+                                         const GLuint *value);
+angle::CallCapture CaptureClientWaitSync(const State &glState,
+                                         bool isCallValid,
+                                         GLsync sync,
+                                         GLbitfield flags,
+                                         GLuint64 timeout,
+                                         GLenum returnValue);
+angle::CallCapture CaptureCompressedTexImage3D(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 CaptureCompressedTexSubImage3D(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 CaptureCopyBufferSubData(const State &glState,
+                                            bool isCallValid,
+                                            BufferBinding readTargetPacked,
+                                            BufferBinding writeTargetPacked,
+                                            GLintptr readOffset,
+                                            GLintptr writeOffset,
+                                            GLsizeiptr size);
+angle::CallCapture CaptureCopyTexSubImage3D(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 CaptureDeleteQueries(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        const QueryID *idsPacked);
+angle::CallCapture CaptureDeleteSamplers(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei count,
+                                         const SamplerID *samplersPacked);
+angle::CallCapture CaptureDeleteSync(const State &glState, bool isCallValid, GLsync sync);
+angle::CallCapture CaptureDeleteTransformFeedbacks(const State &glState,
+                                                   bool isCallValid,
+                                                   GLsizei n,
+                                                   const TransformFeedbackID *idsPacked);
+angle::CallCapture CaptureDeleteVertexArrays(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             const VertexArrayID *arraysPacked);
+angle::CallCapture CaptureDrawArraysInstanced(const State &glState,
+                                              bool isCallValid,
+                                              PrimitiveMode modePacked,
+                                              GLint first,
+                                              GLsizei count,
+                                              GLsizei instancecount);
+angle::CallCapture CaptureDrawBuffers(const State &glState,
+                                      bool isCallValid,
+                                      GLsizei n,
+                                      const GLenum *bufs);
+angle::CallCapture CaptureDrawElementsInstanced(const State &glState,
+                                                bool isCallValid,
+                                                PrimitiveMode modePacked,
+                                                GLsizei count,
+                                                DrawElementsType typePacked,
+                                                const void *indices,
+                                                GLsizei instancecount);
+angle::CallCapture CaptureDrawRangeElements(const State &glState,
+                                            bool isCallValid,
+                                            PrimitiveMode modePacked,
+                                            GLuint start,
+                                            GLuint end,
+                                            GLsizei count,
+                                            DrawElementsType typePacked,
+                                            const void *indices);
+angle::CallCapture CaptureEndQuery(const State &glState, bool isCallValid, QueryType targetPacked);
+angle::CallCapture CaptureEndTransformFeedback(const State &glState, bool isCallValid);
+angle::CallCapture CaptureFenceSync(const State &glState,
+                                    bool isCallValid,
+                                    GLenum condition,
+                                    GLbitfield flags,
+                                    GLsync returnValue);
+angle::CallCapture CaptureFlushMappedBufferRange(const State &glState,
+                                                 bool isCallValid,
+                                                 BufferBinding targetPacked,
+                                                 GLintptr offset,
+                                                 GLsizeiptr length);
+angle::CallCapture CaptureFramebufferTextureLayer(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum target,
+                                                  GLenum attachment,
+                                                  TextureID texturePacked,
+                                                  GLint level,
+                                                  GLint layer);
+angle::CallCapture CaptureGenQueries(const State &glState,
+                                     bool isCallValid,
+                                     GLsizei n,
+                                     QueryID *idsPacked);
+angle::CallCapture CaptureGenSamplers(const State &glState,
+                                      bool isCallValid,
+                                      GLsizei count,
+                                      SamplerID *samplersPacked);
+angle::CallCapture CaptureGenTransformFeedbacks(const State &glState,
+                                                bool isCallValid,
+                                                GLsizei n,
+                                                TransformFeedbackID *idsPacked);
+angle::CallCapture CaptureGenVertexArrays(const State &glState,
+                                          bool isCallValid,
+                                          GLsizei n,
+                                          VertexArrayID *arraysPacked);
+angle::CallCapture CaptureGetActiveUniformBlockName(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformBlockIndex uniformBlockIndexPacked,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLchar *uniformBlockName);
+angle::CallCapture CaptureGetActiveUniformBlockiv(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformBlockIndex uniformBlockIndexPacked,
+                                                  GLenum pname,
+                                                  GLint *params);
+angle::CallCapture CaptureGetActiveUniformsiv(const State &glState,
+                                              bool isCallValid,
+                                              ShaderProgramID programPacked,
+                                              GLsizei uniformCount,
+                                              const GLuint *uniformIndices,
+                                              GLenum pname,
+                                              GLint *params);
+angle::CallCapture CaptureGetBufferParameteri64v(const State &glState,
+                                                 bool isCallValid,
+                                                 BufferBinding targetPacked,
+                                                 GLenum pname,
+                                                 GLint64 *params);
+angle::CallCapture CaptureGetBufferPointerv(const State &glState,
+                                            bool isCallValid,
+                                            BufferBinding targetPacked,
+                                            GLenum pname,
+                                            void **params);
+angle::CallCapture CaptureGetFragDataLocation(const State &glState,
+                                              bool isCallValid,
+                                              ShaderProgramID programPacked,
+                                              const GLchar *name,
+                                              GLint returnValue);
+angle::CallCapture CaptureGetInteger64i_v(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLuint index,
+                                          GLint64 *data);
+angle::CallCapture CaptureGetInteger64v(const State &glState,
+                                        bool isCallValid,
+                                        GLenum pname,
+                                        GLint64 *data);
+angle::CallCapture CaptureGetIntegeri_v(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLuint index,
+                                        GLint *data);
+angle::CallCapture CaptureGetInternalformativ(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              GLenum internalformat,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              GLint *params);
+angle::CallCapture CaptureGetProgramBinary(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLenum *binaryFormat,
+                                           void *binary);
+angle::CallCapture CaptureGetQueryObjectuiv(const State &glState,
+                                            bool isCallValid,
+                                            QueryID idPacked,
+                                            GLenum pname,
+                                            GLuint *params);
+angle::CallCapture CaptureGetQueryiv(const State &glState,
+                                     bool isCallValid,
+                                     QueryType targetPacked,
+                                     GLenum pname,
+                                     GLint *params);
+angle::CallCapture CaptureGetSamplerParameterfv(const State &glState,
+                                                bool isCallValid,
+                                                SamplerID samplerPacked,
+                                                GLenum pname,
+                                                GLfloat *params);
+angle::CallCapture CaptureGetSamplerParameteriv(const State &glState,
+                                                bool isCallValid,
+                                                SamplerID samplerPacked,
+                                                GLenum pname,
+                                                GLint *params);
+angle::CallCapture CaptureGetStringi(const State &glState,
+                                     bool isCallValid,
+                                     GLenum name,
+                                     GLuint index,
+                                     const GLubyte *returnValue);
+angle::CallCapture CaptureGetSynciv(const State &glState,
+                                    bool isCallValid,
+                                    GLsync sync,
+                                    GLenum pname,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLint *values);
+angle::CallCapture CaptureGetTransformFeedbackVarying(const State &glState,
+                                                      bool isCallValid,
+                                                      ShaderProgramID programPacked,
+                                                      GLuint index,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLsizei *size,
+                                                      GLenum *type,
+                                                      GLchar *name);
+angle::CallCapture CaptureGetUniformBlockIndex(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               const GLchar *uniformBlockName,
+                                               GLuint returnValue);
+angle::CallCapture CaptureGetUniformIndices(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            GLsizei uniformCount,
+                                            const GLchar *const *uniformNames,
+                                            GLuint *uniformIndices);
+angle::CallCapture CaptureGetUniformuiv(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        UniformLocation locationPacked,
+                                        GLuint *params);
+angle::CallCapture CaptureGetVertexAttribIiv(const State &glState,
+                                             bool isCallValid,
+                                             GLuint index,
+                                             GLenum pname,
+                                             GLint *params);
+angle::CallCapture CaptureGetVertexAttribIuiv(const State &glState,
+                                              bool isCallValid,
+                                              GLuint index,
+                                              GLenum pname,
+                                              GLuint *params);
+angle::CallCapture CaptureInvalidateFramebuffer(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLsizei numAttachments,
+                                                const GLenum *attachments);
+angle::CallCapture CaptureInvalidateSubFramebuffer(const State &glState,
+                                                   bool isCallValid,
+                                                   GLenum target,
+                                                   GLsizei numAttachments,
+                                                   const GLenum *attachments,
+                                                   GLint x,
+                                                   GLint y,
+                                                   GLsizei width,
+                                                   GLsizei height);
+angle::CallCapture CaptureIsQuery(const State &glState,
+                                  bool isCallValid,
+                                  QueryID idPacked,
+                                  GLboolean returnValue);
+angle::CallCapture CaptureIsSampler(const State &glState,
+                                    bool isCallValid,
+                                    SamplerID samplerPacked,
+                                    GLboolean returnValue);
+angle::CallCapture CaptureIsSync(const State &glState,
+                                 bool isCallValid,
+                                 GLsync sync,
+                                 GLboolean returnValue);
+angle::CallCapture CaptureIsTransformFeedback(const State &glState,
+                                              bool isCallValid,
+                                              TransformFeedbackID idPacked,
+                                              GLboolean returnValue);
+angle::CallCapture CaptureIsVertexArray(const State &glState,
+                                        bool isCallValid,
+                                        VertexArrayID arrayPacked,
+                                        GLboolean returnValue);
+angle::CallCapture CaptureMapBufferRange(const State &glState,
+                                         bool isCallValid,
+                                         BufferBinding targetPacked,
+                                         GLintptr offset,
+                                         GLsizeiptr length,
+                                         GLbitfield access,
+                                         void *returnValue);
+angle::CallCapture CapturePauseTransformFeedback(const State &glState, bool isCallValid);
+angle::CallCapture CaptureProgramBinary(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        GLenum binaryFormat,
+                                        const void *binary,
+                                        GLsizei length);
+angle::CallCapture CaptureProgramParameteri(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            GLenum pname,
+                                            GLint value);
+angle::CallCapture CaptureReadBuffer(const State &glState, bool isCallValid, GLenum src);
+angle::CallCapture CaptureRenderbufferStorageMultisample(const State &glState,
+                                                         bool isCallValid,
+                                                         GLenum target,
+                                                         GLsizei samples,
+                                                         GLenum internalformat,
+                                                         GLsizei width,
+                                                         GLsizei height);
+angle::CallCapture CaptureResumeTransformFeedback(const State &glState, bool isCallValid);
+angle::CallCapture CaptureSamplerParameterf(const State &glState,
+                                            bool isCallValid,
+                                            SamplerID samplerPacked,
+                                            GLenum pname,
+                                            GLfloat param);
+angle::CallCapture CaptureSamplerParameterfv(const State &glState,
+                                             bool isCallValid,
+                                             SamplerID samplerPacked,
+                                             GLenum pname,
+                                             const GLfloat *param);
+angle::CallCapture CaptureSamplerParameteri(const State &glState,
+                                            bool isCallValid,
+                                            SamplerID samplerPacked,
+                                            GLenum pname,
+                                            GLint param);
+angle::CallCapture CaptureSamplerParameteriv(const State &glState,
+                                             bool isCallValid,
+                                             SamplerID samplerPacked,
+                                             GLenum pname,
+                                             const GLint *param);
+angle::CallCapture CaptureTexImage3D(const State &glState,
+                                     bool isCallValid,
+                                     TextureTarget targetPacked,
+                                     GLint level,
+                                     GLint internalformat,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLsizei depth,
+                                     GLint border,
+                                     GLenum format,
+                                     GLenum type,
+                                     const void *pixels);
+angle::CallCapture CaptureTexStorage2D(const State &glState,
+                                       bool isCallValid,
+                                       TextureType targetPacked,
+                                       GLsizei levels,
+                                       GLenum internalformat,
+                                       GLsizei width,
+                                       GLsizei height);
+angle::CallCapture CaptureTexStorage3D(const State &glState,
+                                       bool isCallValid,
+                                       TextureType targetPacked,
+                                       GLsizei levels,
+                                       GLenum internalformat,
+                                       GLsizei width,
+                                       GLsizei height,
+                                       GLsizei depth);
+angle::CallCapture CaptureTexSubImage3D(const State &glState,
+                                        bool isCallValid,
+                                        TextureTarget targetPacked,
+                                        GLint level,
+                                        GLint xoffset,
+                                        GLint yoffset,
+                                        GLint zoffset,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLsizei depth,
+                                        GLenum format,
+                                        GLenum type,
+                                        const void *pixels);
+angle::CallCapture CaptureTransformFeedbackVaryings(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    GLsizei count,
+                                                    const GLchar *const *varyings,
+                                                    GLenum bufferMode);
+angle::CallCapture CaptureUniform1ui(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLuint v0);
+angle::CallCapture CaptureUniform1uiv(const State &glState,
+                                      bool isCallValid,
+                                      UniformLocation locationPacked,
+                                      GLsizei count,
+                                      const GLuint *value);
+angle::CallCapture CaptureUniform2ui(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLuint v0,
+                                     GLuint v1);
+angle::CallCapture CaptureUniform2uiv(const State &glState,
+                                      bool isCallValid,
+                                      UniformLocation locationPacked,
+                                      GLsizei count,
+                                      const GLuint *value);
+angle::CallCapture CaptureUniform3ui(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLuint v0,
+                                     GLuint v1,
+                                     GLuint v2);
+angle::CallCapture CaptureUniform3uiv(const State &glState,
+                                      bool isCallValid,
+                                      UniformLocation locationPacked,
+                                      GLsizei count,
+                                      const GLuint *value);
+angle::CallCapture CaptureUniform4ui(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLuint v0,
+                                     GLuint v1,
+                                     GLuint v2,
+                                     GLuint v3);
+angle::CallCapture CaptureUniform4uiv(const State &glState,
+                                      bool isCallValid,
+                                      UniformLocation locationPacked,
+                                      GLsizei count,
+                                      const GLuint *value);
+angle::CallCapture CaptureUniformBlockBinding(const State &glState,
+                                              bool isCallValid,
+                                              ShaderProgramID programPacked,
+                                              UniformBlockIndex uniformBlockIndexPacked,
+                                              GLuint uniformBlockBinding);
+angle::CallCapture CaptureUniformMatrix2x3fv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value);
+angle::CallCapture CaptureUniformMatrix2x4fv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value);
+angle::CallCapture CaptureUniformMatrix3x2fv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value);
+angle::CallCapture CaptureUniformMatrix3x4fv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value);
+angle::CallCapture CaptureUniformMatrix4x2fv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value);
+angle::CallCapture CaptureUniformMatrix4x3fv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value);
+angle::CallCapture CaptureUnmapBuffer(const State &glState,
+                                      bool isCallValid,
+                                      BufferBinding targetPacked,
+                                      GLboolean returnValue);
+angle::CallCapture CaptureVertexAttribDivisor(const State &glState,
+                                              bool isCallValid,
+                                              GLuint index,
+                                              GLuint divisor);
+angle::CallCapture CaptureVertexAttribI4i(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          GLint x,
+                                          GLint y,
+                                          GLint z,
+                                          GLint w);
+angle::CallCapture CaptureVertexAttribI4iv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLint *v);
+angle::CallCapture CaptureVertexAttribI4ui(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLuint x,
+                                           GLuint y,
+                                           GLuint z,
+                                           GLuint w);
+angle::CallCapture CaptureVertexAttribI4uiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLuint *v);
+angle::CallCapture CaptureVertexAttribIPointer(const State &glState,
+                                               bool isCallValid,
+                                               GLuint index,
+                                               GLint size,
+                                               VertexAttribType typePacked,
+                                               GLsizei stride,
+                                               const void *pointer);
+angle::CallCapture CaptureWaitSync(const State &glState,
+                                   bool isCallValid,
+                                   GLsync sync,
+                                   GLbitfield flags,
+                                   GLuint64 timeout);
+
+// Parameter Captures
+
+void CaptureClearBufferfv_value(const State &glState,
+                                bool isCallValid,
+                                GLenum buffer,
+                                GLint drawbuffer,
+                                const GLfloat *value,
+                                angle::ParamCapture *paramCapture);
+void CaptureClearBufferiv_value(const State &glState,
+                                bool isCallValid,
+                                GLenum buffer,
+                                GLint drawbuffer,
+                                const GLint *value,
+                                angle::ParamCapture *paramCapture);
+void CaptureClearBufferuiv_value(const State &glState,
+                                 bool isCallValid,
+                                 GLenum buffer,
+                                 GLint drawbuffer,
+                                 const GLuint *value,
+                                 angle::ParamCapture *paramCapture);
+void CaptureCompressedTexImage3D_data(const State &glState,
+                                      bool isCallValid,
+                                      TextureTarget targetPacked,
+                                      GLint level,
+                                      GLenum internalformat,
+                                      GLsizei width,
+                                      GLsizei height,
+                                      GLsizei depth,
+                                      GLint border,
+                                      GLsizei imageSize,
+                                      const void *data,
+                                      angle::ParamCapture *paramCapture);
+void CaptureCompressedTexSubImage3D_data(const State &glState,
+                                         bool isCallValid,
+                                         TextureTarget targetPacked,
+                                         GLint level,
+                                         GLint xoffset,
+                                         GLint yoffset,
+                                         GLint zoffset,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLenum format,
+                                         GLsizei imageSize,
+                                         const void *data,
+                                         angle::ParamCapture *paramCapture);
+void CaptureDeleteQueries_idsPacked(const State &glState,
+                                    bool isCallValid,
+                                    GLsizei n,
+                                    const QueryID *idsPacked,
+                                    angle::ParamCapture *paramCapture);
+void CaptureDeleteSamplers_samplersPacked(const State &glState,
+                                          bool isCallValid,
+                                          GLsizei count,
+                                          const SamplerID *samplersPacked,
+                                          angle::ParamCapture *paramCapture);
+void CaptureDeleteTransformFeedbacks_idsPacked(const State &glState,
+                                               bool isCallValid,
+                                               GLsizei n,
+                                               const TransformFeedbackID *idsPacked,
+                                               angle::ParamCapture *paramCapture);
+void CaptureDeleteVertexArrays_arraysPacked(const State &glState,
+                                            bool isCallValid,
+                                            GLsizei n,
+                                            const VertexArrayID *arraysPacked,
+                                            angle::ParamCapture *paramCapture);
+void CaptureDrawBuffers_bufs(const State &glState,
+                             bool isCallValid,
+                             GLsizei n,
+                             const GLenum *bufs,
+                             angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstanced_indices(const State &glState,
+                                          bool isCallValid,
+                                          PrimitiveMode modePacked,
+                                          GLsizei count,
+                                          DrawElementsType typePacked,
+                                          const void *indices,
+                                          GLsizei instancecount,
+                                          angle::ParamCapture *paramCapture);
+void CaptureDrawRangeElements_indices(const State &glState,
+                                      bool isCallValid,
+                                      PrimitiveMode modePacked,
+                                      GLuint start,
+                                      GLuint end,
+                                      GLsizei count,
+                                      DrawElementsType typePacked,
+                                      const void *indices,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGenQueries_idsPacked(const State &glState,
+                                 bool isCallValid,
+                                 GLsizei n,
+                                 QueryID *idsPacked,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGenSamplers_samplersPacked(const State &glState,
+                                       bool isCallValid,
+                                       GLsizei count,
+                                       SamplerID *samplersPacked,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGenTransformFeedbacks_idsPacked(const State &glState,
+                                            bool isCallValid,
+                                            GLsizei n,
+                                            TransformFeedbackID *idsPacked,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGenVertexArrays_arraysPacked(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei n,
+                                         VertexArrayID *arraysPacked,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniformBlockName_length(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformBlockIndex uniformBlockIndexPacked,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLchar *uniformBlockName,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniformBlockName_uniformBlockName(const State &glState,
+                                                       bool isCallValid,
+                                                       ShaderProgramID programPacked,
+                                                       UniformBlockIndex uniformBlockIndexPacked,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLchar *uniformBlockName,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniformBlockiv_params(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformBlockIndex uniformBlockIndexPacked,
+                                           GLenum pname,
+                                           GLint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniformsiv_uniformIndices(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               GLsizei uniformCount,
+                                               const GLuint *uniformIndices,
+                                               GLenum pname,
+                                               GLint *params,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniformsiv_params(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       GLsizei uniformCount,
+                                       const GLuint *uniformIndices,
+                                       GLenum pname,
+                                       GLint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetBufferParameteri64v_params(const State &glState,
+                                          bool isCallValid,
+                                          BufferBinding targetPacked,
+                                          GLenum pname,
+                                          GLint64 *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetBufferPointerv_params(const State &glState,
+                                     bool isCallValid,
+                                     BufferBinding targetPacked,
+                                     GLenum pname,
+                                     void **params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetFragDataLocation_name(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     const GLchar *name,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetInteger64i_v_data(const State &glState,
+                                 bool isCallValid,
+                                 GLenum target,
+                                 GLuint index,
+                                 GLint64 *data,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetInteger64v_data(const State &glState,
+                               bool isCallValid,
+                               GLenum pname,
+                               GLint64 *data,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetIntegeri_v_data(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               GLuint index,
+                               GLint *data,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetInternalformativ_params(const State &glState,
+                                       bool isCallValid,
+                                       GLenum target,
+                                       GLenum internalformat,
+                                       GLenum pname,
+                                       GLsizei bufSize,
+                                       GLint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetProgramBinary_length(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLenum *binaryFormat,
+                                    void *binary,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetProgramBinary_binaryFormat(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLenum *binaryFormat,
+                                          void *binary,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetProgramBinary_binary(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLenum *binaryFormat,
+                                    void *binary,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectuiv_params(const State &glState,
+                                     bool isCallValid,
+                                     QueryID idPacked,
+                                     GLenum pname,
+                                     GLuint *params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetQueryiv_params(const State &glState,
+                              bool isCallValid,
+                              QueryType targetPacked,
+                              GLenum pname,
+                              GLint *params,
+                              angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterfv_params(const State &glState,
+                                         bool isCallValid,
+                                         SamplerID samplerPacked,
+                                         GLenum pname,
+                                         GLfloat *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameteriv_params(const State &glState,
+                                         bool isCallValid,
+                                         SamplerID samplerPacked,
+                                         GLenum pname,
+                                         GLint *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetSynciv_length(const State &glState,
+                             bool isCallValid,
+                             GLsync sync,
+                             GLenum pname,
+                             GLsizei bufSize,
+                             GLsizei *length,
+                             GLint *values,
+                             angle::ParamCapture *paramCapture);
+void CaptureGetSynciv_values(const State &glState,
+                             bool isCallValid,
+                             GLsync sync,
+                             GLenum pname,
+                             GLsizei bufSize,
+                             GLsizei *length,
+                             GLint *values,
+                             angle::ParamCapture *paramCapture);
+void CaptureGetTransformFeedbackVarying_length(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               GLuint index,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLsizei *size,
+                                               GLenum *type,
+                                               GLchar *name,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetTransformFeedbackVarying_size(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLuint index,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLsizei *size,
+                                             GLenum *type,
+                                             GLchar *name,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetTransformFeedbackVarying_type(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLuint index,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLsizei *size,
+                                             GLenum *type,
+                                             GLchar *name,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetTransformFeedbackVarying_name(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLuint index,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLsizei *size,
+                                             GLenum *type,
+                                             GLchar *name,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetUniformBlockIndex_uniformBlockName(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  const GLchar *uniformBlockName,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetUniformIndices_uniformNames(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           GLsizei uniformCount,
+                                           const GLchar *const *uniformNames,
+                                           GLuint *uniformIndices,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetUniformIndices_uniformIndices(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLsizei uniformCount,
+                                             const GLchar *const *uniformNames,
+                                             GLuint *uniformIndices,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetUniformuiv_params(const State &glState,
+                                 bool isCallValid,
+                                 ShaderProgramID programPacked,
+                                 UniformLocation locationPacked,
+                                 GLuint *params,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribIiv_params(const State &glState,
+                                      bool isCallValid,
+                                      GLuint index,
+                                      GLenum pname,
+                                      GLint *params,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribIuiv_params(const State &glState,
+                                       bool isCallValid,
+                                       GLuint index,
+                                       GLenum pname,
+                                       GLuint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureInvalidateFramebuffer_attachments(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              GLsizei numAttachments,
+                                              const GLenum *attachments,
+                                              angle::ParamCapture *paramCapture);
+void CaptureInvalidateSubFramebuffer_attachments(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum target,
+                                                 GLsizei numAttachments,
+                                                 const GLenum *attachments,
+                                                 GLint x,
+                                                 GLint y,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureProgramBinary_binary(const State &glState,
+                                 bool isCallValid,
+                                 ShaderProgramID programPacked,
+                                 GLenum binaryFormat,
+                                 const void *binary,
+                                 GLsizei length,
+                                 angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterfv_param(const State &glState,
+                                     bool isCallValid,
+                                     SamplerID samplerPacked,
+                                     GLenum pname,
+                                     const GLfloat *param,
+                                     angle::ParamCapture *paramCapture);
+void CaptureSamplerParameteriv_param(const State &glState,
+                                     bool isCallValid,
+                                     SamplerID samplerPacked,
+                                     GLenum pname,
+                                     const GLint *param,
+                                     angle::ParamCapture *paramCapture);
+void CaptureTexImage3D_pixels(const State &glState,
+                              bool isCallValid,
+                              TextureTarget targetPacked,
+                              GLint level,
+                              GLint internalformat,
+                              GLsizei width,
+                              GLsizei height,
+                              GLsizei depth,
+                              GLint border,
+                              GLenum format,
+                              GLenum type,
+                              const void *pixels,
+                              angle::ParamCapture *paramCapture);
+void CaptureTexSubImage3D_pixels(const State &glState,
+                                 bool isCallValid,
+                                 TextureTarget targetPacked,
+                                 GLint level,
+                                 GLint xoffset,
+                                 GLint yoffset,
+                                 GLint zoffset,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLsizei depth,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void *pixels,
+                                 angle::ParamCapture *paramCapture);
+void CaptureTransformFeedbackVaryings_varyings(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               GLsizei count,
+                                               const GLchar *const *varyings,
+                                               GLenum bufferMode,
+                                               angle::ParamCapture *paramCapture);
+void CaptureUniform1uiv_value(const State &glState,
+                              bool isCallValid,
+                              UniformLocation locationPacked,
+                              GLsizei count,
+                              const GLuint *value,
+                              angle::ParamCapture *paramCapture);
+void CaptureUniform2uiv_value(const State &glState,
+                              bool isCallValid,
+                              UniformLocation locationPacked,
+                              GLsizei count,
+                              const GLuint *value,
+                              angle::ParamCapture *paramCapture);
+void CaptureUniform3uiv_value(const State &glState,
+                              bool isCallValid,
+                              UniformLocation locationPacked,
+                              GLsizei count,
+                              const GLuint *value,
+                              angle::ParamCapture *paramCapture);
+void CaptureUniform4uiv_value(const State &glState,
+                              bool isCallValid,
+                              UniformLocation locationPacked,
+                              GLsizei count,
+                              const GLuint *value,
+                              angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix2x3fv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix2x4fv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix3x2fv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix3x4fv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix4x2fv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix4x3fv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI4iv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI4uiv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLuint *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureVertexAttribIPointer_pointer(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLint size,
+                                         VertexAttribType typePacked,
+                                         GLsizei stride,
+                                         const void *pointer,
+                                         angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_1_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_1_autogen.h
new file mode 100644
index 0000000000..01c636430e
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_1_autogen.h
@@ -0,0 +1,728 @@
+// 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_3_1_autogen.h:
+//   Capture functions for the OpenGL ES 3.1 entry points.
+
+#ifndef LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+angle::CallCapture CaptureActiveShaderProgram(const State &glState,
+                                              bool isCallValid,
+                                              ProgramPipelineID pipelinePacked,
+                                              ShaderProgramID programPacked);
+angle::CallCapture CaptureBindImageTexture(const State &glState,
+                                           bool isCallValid,
+                                           GLuint unit,
+                                           TextureID texturePacked,
+                                           GLint level,
+                                           GLboolean layered,
+                                           GLint layer,
+                                           GLenum access,
+                                           GLenum format);
+angle::CallCapture CaptureBindProgramPipeline(const State &glState,
+                                              bool isCallValid,
+                                              ProgramPipelineID pipelinePacked);
+angle::CallCapture CaptureBindVertexBuffer(const State &glState,
+                                           bool isCallValid,
+                                           GLuint bindingindex,
+                                           BufferID bufferPacked,
+                                           GLintptr offset,
+                                           GLsizei stride);
+angle::CallCapture CaptureCreateShaderProgramv(const State &glState,
+                                               bool isCallValid,
+                                               ShaderType typePacked,
+                                               GLsizei count,
+                                               const GLchar *const *strings,
+                                               GLuint returnValue);
+angle::CallCapture CaptureDeleteProgramPipelines(const State &glState,
+                                                 bool isCallValid,
+                                                 GLsizei n,
+                                                 const ProgramPipelineID *pipelinesPacked);
+angle::CallCapture CaptureDispatchCompute(const State &glState,
+                                          bool isCallValid,
+                                          GLuint num_groups_x,
+                                          GLuint num_groups_y,
+                                          GLuint num_groups_z);
+angle::CallCapture CaptureDispatchComputeIndirect(const State &glState,
+                                                  bool isCallValid,
+                                                  GLintptr indirect);
+angle::CallCapture CaptureDrawArraysIndirect(const State &glState,
+                                             bool isCallValid,
+                                             PrimitiveMode modePacked,
+                                             const void *indirect);
+angle::CallCapture CaptureDrawElementsIndirect(const State &glState,
+                                               bool isCallValid,
+                                               PrimitiveMode modePacked,
+                                               DrawElementsType typePacked,
+                                               const void *indirect);
+angle::CallCapture CaptureFramebufferParameteri(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLenum pname,
+                                                GLint param);
+angle::CallCapture CaptureGenProgramPipelines(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              ProgramPipelineID *pipelinesPacked);
+angle::CallCapture CaptureGetBooleani_v(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLuint index,
+                                        GLboolean *data);
+angle::CallCapture CaptureGetFramebufferParameteriv(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum target,
+                                                    GLenum pname,
+                                                    GLint *params);
+angle::CallCapture CaptureGetMultisamplefv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum pname,
+                                           GLuint index,
+                                           GLfloat *val);
+angle::CallCapture CaptureGetProgramInterfaceiv(const State &glState,
+                                                bool isCallValid,
+                                                ShaderProgramID programPacked,
+                                                GLenum programInterface,
+                                                GLenum pname,
+                                                GLint *params);
+angle::CallCapture CaptureGetProgramPipelineInfoLog(const State &glState,
+                                                    bool isCallValid,
+                                                    ProgramPipelineID pipelinePacked,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLchar *infoLog);
+angle::CallCapture CaptureGetProgramPipelineiv(const State &glState,
+                                               bool isCallValid,
+                                               ProgramPipelineID pipelinePacked,
+                                               GLenum pname,
+                                               GLint *params);
+angle::CallCapture CaptureGetProgramResourceIndex(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  GLenum programInterface,
+                                                  const GLchar *name,
+                                                  GLuint returnValue);
+angle::CallCapture CaptureGetProgramResourceLocation(const State &glState,
+                                                     bool isCallValid,
+                                                     ShaderProgramID programPacked,
+                                                     GLenum programInterface,
+                                                     const GLchar *name,
+                                                     GLint returnValue);
+angle::CallCapture CaptureGetProgramResourceName(const State &glState,
+                                                 bool isCallValid,
+                                                 ShaderProgramID programPacked,
+                                                 GLenum programInterface,
+                                                 GLuint index,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLchar *name);
+angle::CallCapture CaptureGetProgramResourceiv(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               GLenum programInterface,
+                                               GLuint index,
+                                               GLsizei propCount,
+                                               const GLenum *props,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *params);
+angle::CallCapture CaptureGetTexLevelParameterfv(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureTarget targetPacked,
+                                                 GLint level,
+                                                 GLenum pname,
+                                                 GLfloat *params);
+angle::CallCapture CaptureGetTexLevelParameteriv(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureTarget targetPacked,
+                                                 GLint level,
+                                                 GLenum pname,
+                                                 GLint *params);
+angle::CallCapture CaptureIsProgramPipeline(const State &glState,
+                                            bool isCallValid,
+                                            ProgramPipelineID pipelinePacked,
+                                            GLboolean returnValue);
+angle::CallCapture CaptureMemoryBarrier(const State &glState,
+                                        bool isCallValid,
+                                        GLbitfield barriers);
+angle::CallCapture CaptureMemoryBarrierByRegion(const State &glState,
+                                                bool isCallValid,
+                                                GLbitfield barriers);
+angle::CallCapture CaptureProgramUniform1f(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLfloat v0);
+angle::CallCapture CaptureProgramUniform1fv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLfloat *value);
+angle::CallCapture CaptureProgramUniform1i(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLint v0);
+angle::CallCapture CaptureProgramUniform1iv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLint *value);
+angle::CallCapture CaptureProgramUniform1ui(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLuint v0);
+angle::CallCapture CaptureProgramUniform1uiv(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             const GLuint *value);
+angle::CallCapture CaptureProgramUniform2f(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLfloat v0,
+                                           GLfloat v1);
+angle::CallCapture CaptureProgramUniform2fv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLfloat *value);
+angle::CallCapture CaptureProgramUniform2i(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLint v0,
+                                           GLint v1);
+angle::CallCapture CaptureProgramUniform2iv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLint *value);
+angle::CallCapture CaptureProgramUniform2ui(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLuint v0,
+                                            GLuint v1);
+angle::CallCapture CaptureProgramUniform2uiv(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             const GLuint *value);
+angle::CallCapture CaptureProgramUniform3f(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLfloat v0,
+                                           GLfloat v1,
+                                           GLfloat v2);
+angle::CallCapture CaptureProgramUniform3fv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLfloat *value);
+angle::CallCapture CaptureProgramUniform3i(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLint v0,
+                                           GLint v1,
+                                           GLint v2);
+angle::CallCapture CaptureProgramUniform3iv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLint *value);
+angle::CallCapture CaptureProgramUniform3ui(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLuint v0,
+                                            GLuint v1,
+                                            GLuint v2);
+angle::CallCapture CaptureProgramUniform3uiv(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             const GLuint *value);
+angle::CallCapture CaptureProgramUniform4f(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLfloat v0,
+                                           GLfloat v1,
+                                           GLfloat v2,
+                                           GLfloat v3);
+angle::CallCapture CaptureProgramUniform4fv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLfloat *value);
+angle::CallCapture CaptureProgramUniform4i(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLint v0,
+                                           GLint v1,
+                                           GLint v2,
+                                           GLint v3);
+angle::CallCapture CaptureProgramUniform4iv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLint *value);
+angle::CallCapture CaptureProgramUniform4ui(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLuint v0,
+                                            GLuint v1,
+                                            GLuint v2,
+                                            GLuint v3);
+angle::CallCapture CaptureProgramUniform4uiv(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             const GLuint *value);
+angle::CallCapture CaptureProgramUniformMatrix2fv(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformLocation locationPacked,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value);
+angle::CallCapture CaptureProgramUniformMatrix2x3fv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLfloat *value);
+angle::CallCapture CaptureProgramUniformMatrix2x4fv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLfloat *value);
+angle::CallCapture CaptureProgramUniformMatrix3fv(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformLocation locationPacked,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value);
+angle::CallCapture CaptureProgramUniformMatrix3x2fv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLfloat *value);
+angle::CallCapture CaptureProgramUniformMatrix3x4fv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLfloat *value);
+angle::CallCapture CaptureProgramUniformMatrix4fv(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformLocation locationPacked,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value);
+angle::CallCapture CaptureProgramUniformMatrix4x2fv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLfloat *value);
+angle::CallCapture CaptureProgramUniformMatrix4x3fv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLfloat *value);
+angle::CallCapture CaptureSampleMaski(const State &glState,
+                                      bool isCallValid,
+                                      GLuint maskNumber,
+                                      GLbitfield mask);
+angle::CallCapture CaptureTexStorage2DMultisample(const State &glState,
+                                                  bool isCallValid,
+                                                  TextureType targetPacked,
+                                                  GLsizei samples,
+                                                  GLenum internalformat,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLboolean fixedsamplelocations);
+angle::CallCapture CaptureUseProgramStages(const State &glState,
+                                           bool isCallValid,
+                                           ProgramPipelineID pipelinePacked,
+                                           GLbitfield stages,
+                                           ShaderProgramID programPacked);
+angle::CallCapture CaptureValidateProgramPipeline(const State &glState,
+                                                  bool isCallValid,
+                                                  ProgramPipelineID pipelinePacked);
+angle::CallCapture CaptureVertexAttribBinding(const State &glState,
+                                              bool isCallValid,
+                                              GLuint attribindex,
+                                              GLuint bindingindex);
+angle::CallCapture CaptureVertexAttribFormat(const State &glState,
+                                             bool isCallValid,
+                                             GLuint attribindex,
+                                             GLint size,
+                                             VertexAttribType typePacked,
+                                             GLboolean normalized,
+                                             GLuint relativeoffset);
+angle::CallCapture CaptureVertexAttribIFormat(const State &glState,
+                                              bool isCallValid,
+                                              GLuint attribindex,
+                                              GLint size,
+                                              VertexAttribType typePacked,
+                                              GLuint relativeoffset);
+angle::CallCapture CaptureVertexBindingDivisor(const State &glState,
+                                               bool isCallValid,
+                                               GLuint bindingindex,
+                                               GLuint divisor);
+
+// Parameter Captures
+
+void CaptureCreateShaderProgramv_strings(const State &glState,
+                                         bool isCallValid,
+                                         ShaderType typePacked,
+                                         GLsizei count,
+                                         const GLchar *const *strings,
+                                         angle::ParamCapture *paramCapture);
+void CaptureDeleteProgramPipelines_pipelinesPacked(const State &glState,
+                                                   bool isCallValid,
+                                                   GLsizei n,
+                                                   const ProgramPipelineID *pipelinesPacked,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureDrawArraysIndirect_indirect(const State &glState,
+                                        bool isCallValid,
+                                        PrimitiveMode modePacked,
+                                        const void *indirect,
+                                        angle::ParamCapture *paramCapture);
+void CaptureDrawElementsIndirect_indirect(const State &glState,
+                                          bool isCallValid,
+                                          PrimitiveMode modePacked,
+                                          DrawElementsType typePacked,
+                                          const void *indirect,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGenProgramPipelines_pipelinesPacked(const State &glState,
+                                                bool isCallValid,
+                                                GLsizei n,
+                                                ProgramPipelineID *pipelinesPacked,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetBooleani_v_data(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               GLuint index,
+                               GLboolean *data,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetFramebufferParameteriv_params(const State &glState,
+                                             bool isCallValid,
+                                             GLenum target,
+                                             GLenum pname,
+                                             GLint *params,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetMultisamplefv_val(const State &glState,
+                                 bool isCallValid,
+                                 GLenum pname,
+                                 GLuint index,
+                                 GLfloat *val,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetProgramInterfaceiv_params(const State &glState,
+                                         bool isCallValid,
+                                         ShaderProgramID programPacked,
+                                         GLenum programInterface,
+                                         GLenum pname,
+                                         GLint *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetProgramPipelineInfoLog_length(const State &glState,
+                                             bool isCallValid,
+                                             ProgramPipelineID pipelinePacked,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLchar *infoLog,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetProgramPipelineInfoLog_infoLog(const State &glState,
+                                              bool isCallValid,
+                                              ProgramPipelineID pipelinePacked,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLchar *infoLog,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetProgramPipelineiv_params(const State &glState,
+                                        bool isCallValid,
+                                        ProgramPipelineID pipelinePacked,
+                                        GLenum pname,
+                                        GLint *params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceIndex_name(const State &glState,
+                                         bool isCallValid,
+                                         ShaderProgramID programPacked,
+                                         GLenum programInterface,
+                                         const GLchar *name,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceLocation_name(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            GLenum programInterface,
+                                            const GLchar *name,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceName_length(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          GLenum programInterface,
+                                          GLuint index,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLchar *name,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceName_name(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        GLenum programInterface,
+                                        GLuint index,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLchar *name,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceiv_props(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       GLenum programInterface,
+                                       GLuint index,
+                                       GLsizei propCount,
+                                       const GLenum *props,
+                                       GLsizei bufSize,
+                                       GLsizei *length,
+                                       GLint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceiv_length(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        GLenum programInterface,
+                                        GLuint index,
+                                        GLsizei propCount,
+                                        const GLenum *props,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLint *params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceiv_params(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        GLenum programInterface,
+                                        GLuint index,
+                                        GLsizei propCount,
+                                        const GLenum *props,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLint *params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetTexLevelParameterfv_params(const State &glState,
+                                          bool isCallValid,
+                                          TextureTarget targetPacked,
+                                          GLint level,
+                                          GLenum pname,
+                                          GLfloat *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetTexLevelParameteriv_params(const State &glState,
+                                          bool isCallValid,
+                                          TextureTarget targetPacked,
+                                          GLint level,
+                                          GLenum pname,
+                                          GLint *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureProgramUniform1fv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLfloat *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform1iv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLint *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform1uiv_value(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLuint *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureProgramUniform2fv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLfloat *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform2iv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLint *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform2uiv_value(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLuint *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureProgramUniform3fv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLfloat *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform3iv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLint *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform3uiv_value(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLuint *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureProgramUniform4fv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLfloat *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform4iv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLint *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform4uiv_value(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLuint *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2fv_value(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          UniformLocation locationPacked,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const GLfloat *value,
+                                          angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2x3fv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLfloat *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2x4fv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLfloat *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3fv_value(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          UniformLocation locationPacked,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const GLfloat *value,
+                                          angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3x2fv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLfloat *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3x4fv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLfloat *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4fv_value(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          UniformLocation locationPacked,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const GLfloat *value,
+                                          angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4x2fv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLfloat *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4x3fv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLfloat *value,
+                                            angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_2_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_2_autogen.h
new file mode 100644
index 0000000000..80001a0348
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_2_autogen.h
@@ -0,0 +1,553 @@
+// 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_3_2_autogen.h:
+//   Capture functions for the OpenGL ES 3.2 entry points.
+
+#ifndef LIBANGLE_CAPTURE_GLES_3_2_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GLES_3_2_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+angle::CallCapture CaptureBlendBarrier(const State &glState, bool isCallValid);
+angle::CallCapture CaptureBlendEquationSeparatei(const State &glState,
+                                                 bool isCallValid,
+                                                 GLuint buf,
+                                                 GLenum modeRGB,
+                                                 GLenum modeAlpha);
+angle::CallCapture CaptureBlendEquationi(const State &glState,
+                                         bool isCallValid,
+                                         GLuint buf,
+                                         GLenum mode);
+angle::CallCapture CaptureBlendFuncSeparatei(const State &glState,
+                                             bool isCallValid,
+                                             GLuint buf,
+                                             GLenum srcRGB,
+                                             GLenum dstRGB,
+                                             GLenum srcAlpha,
+                                             GLenum dstAlpha);
+angle::CallCapture CaptureBlendFunci(const State &glState,
+                                     bool isCallValid,
+                                     GLuint buf,
+                                     GLenum src,
+                                     GLenum dst);
+angle::CallCapture CaptureColorMaski(const State &glState,
+                                     bool isCallValid,
+                                     GLuint index,
+                                     GLboolean r,
+                                     GLboolean g,
+                                     GLboolean b,
+                                     GLboolean a);
+angle::CallCapture CaptureCopyImageSubData(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);
+angle::CallCapture CaptureDebugMessageCallback(const State &glState,
+                                               bool isCallValid,
+                                               GLDEBUGPROC callback,
+                                               const void *userParam);
+angle::CallCapture CaptureDebugMessageControl(const State &glState,
+                                              bool isCallValid,
+                                              GLenum source,
+                                              GLenum type,
+                                              GLenum severity,
+                                              GLsizei count,
+                                              const GLuint *ids,
+                                              GLboolean enabled);
+angle::CallCapture CaptureDebugMessageInsert(const State &glState,
+                                             bool isCallValid,
+                                             GLenum source,
+                                             GLenum type,
+                                             GLuint id,
+                                             GLenum severity,
+                                             GLsizei length,
+                                             const GLchar *buf);
+angle::CallCapture CaptureDisablei(const State &glState,
+                                   bool isCallValid,
+                                   GLenum target,
+                                   GLuint index);
+angle::CallCapture CaptureDrawElementsBaseVertex(const State &glState,
+                                                 bool isCallValid,
+                                                 PrimitiveMode modePacked,
+                                                 GLsizei count,
+                                                 DrawElementsType typePacked,
+                                                 const void *indices,
+                                                 GLint basevertex);
+angle::CallCapture CaptureDrawElementsInstancedBaseVertex(const State &glState,
+                                                          bool isCallValid,
+                                                          PrimitiveMode modePacked,
+                                                          GLsizei count,
+                                                          DrawElementsType typePacked,
+                                                          const void *indices,
+                                                          GLsizei instancecount,
+                                                          GLint basevertex);
+angle::CallCapture CaptureDrawRangeElementsBaseVertex(const State &glState,
+                                                      bool isCallValid,
+                                                      PrimitiveMode modePacked,
+                                                      GLuint start,
+                                                      GLuint end,
+                                                      GLsizei count,
+                                                      DrawElementsType typePacked,
+                                                      const void *indices,
+                                                      GLint basevertex);
+angle::CallCapture CaptureEnablei(const State &glState,
+                                  bool isCallValid,
+                                  GLenum target,
+                                  GLuint index);
+angle::CallCapture CaptureFramebufferTexture(const State &glState,
+                                             bool isCallValid,
+                                             GLenum target,
+                                             GLenum attachment,
+                                             TextureID texturePacked,
+                                             GLint level);
+angle::CallCapture CaptureGetDebugMessageLog(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 CaptureGetGraphicsResetStatus(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum returnValue);
+angle::CallCapture CaptureGetObjectLabel(const State &glState,
+                                         bool isCallValid,
+                                         GLenum identifier,
+                                         GLuint name,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLchar *label);
+angle::CallCapture CaptureGetObjectPtrLabel(const State &glState,
+                                            bool isCallValid,
+                                            const void *ptr,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLchar *label);
+angle::CallCapture CaptureGetPointerv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      void **params);
+angle::CallCapture CaptureGetSamplerParameterIiv(const State &glState,
+                                                 bool isCallValid,
+                                                 SamplerID samplerPacked,
+                                                 GLenum pname,
+                                                 GLint *params);
+angle::CallCapture CaptureGetSamplerParameterIuiv(const State &glState,
+                                                  bool isCallValid,
+                                                  SamplerID samplerPacked,
+                                                  GLenum pname,
+                                                  GLuint *params);
+angle::CallCapture CaptureGetTexParameterIiv(const State &glState,
+                                             bool isCallValid,
+                                             TextureType targetPacked,
+                                             GLenum pname,
+                                             GLint *params);
+angle::CallCapture CaptureGetTexParameterIuiv(const State &glState,
+                                              bool isCallValid,
+                                              TextureType targetPacked,
+                                              GLenum pname,
+                                              GLuint *params);
+angle::CallCapture CaptureGetnUniformfv(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        UniformLocation locationPacked,
+                                        GLsizei bufSize,
+                                        GLfloat *params);
+angle::CallCapture CaptureGetnUniformiv(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        UniformLocation locationPacked,
+                                        GLsizei bufSize,
+                                        GLint *params);
+angle::CallCapture CaptureGetnUniformuiv(const State &glState,
+                                         bool isCallValid,
+                                         ShaderProgramID programPacked,
+                                         UniformLocation locationPacked,
+                                         GLsizei bufSize,
+                                         GLuint *params);
+angle::CallCapture CaptureIsEnabledi(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLuint index,
+                                     GLboolean returnValue);
+angle::CallCapture CaptureMinSampleShading(const State &glState, bool isCallValid, GLfloat value);
+angle::CallCapture CaptureObjectLabel(const State &glState,
+                                      bool isCallValid,
+                                      GLenum identifier,
+                                      GLuint name,
+                                      GLsizei length,
+                                      const GLchar *label);
+angle::CallCapture CaptureObjectPtrLabel(const State &glState,
+                                         bool isCallValid,
+                                         const void *ptr,
+                                         GLsizei length,
+                                         const GLchar *label);
+angle::CallCapture CapturePatchParameteri(const State &glState,
+                                          bool isCallValid,
+                                          GLenum pname,
+                                          GLint value);
+angle::CallCapture CapturePopDebugGroup(const State &glState, bool isCallValid);
+angle::CallCapture CapturePrimitiveBoundingBox(const State &glState,
+                                               bool isCallValid,
+                                               GLfloat minX,
+                                               GLfloat minY,
+                                               GLfloat minZ,
+                                               GLfloat minW,
+                                               GLfloat maxX,
+                                               GLfloat maxY,
+                                               GLfloat maxZ,
+                                               GLfloat maxW);
+angle::CallCapture CapturePushDebugGroup(const State &glState,
+                                         bool isCallValid,
+                                         GLenum source,
+                                         GLuint id,
+                                         GLsizei length,
+                                         const GLchar *message);
+angle::CallCapture CaptureReadnPixels(const State &glState,
+                                      bool isCallValid,
+                                      GLint x,
+                                      GLint y,
+                                      GLsizei width,
+                                      GLsizei height,
+                                      GLenum format,
+                                      GLenum type,
+                                      GLsizei bufSize,
+                                      void *data);
+angle::CallCapture CaptureSamplerParameterIiv(const State &glState,
+                                              bool isCallValid,
+                                              SamplerID samplerPacked,
+                                              GLenum pname,
+                                              const GLint *param);
+angle::CallCapture CaptureSamplerParameterIuiv(const State &glState,
+                                               bool isCallValid,
+                                               SamplerID samplerPacked,
+                                               GLenum pname,
+                                               const GLuint *param);
+angle::CallCapture CaptureTexBuffer(const State &glState,
+                                    bool isCallValid,
+                                    TextureType targetPacked,
+                                    GLenum internalformat,
+                                    BufferID bufferPacked);
+angle::CallCapture CaptureTexBufferRange(const State &glState,
+                                         bool isCallValid,
+                                         TextureType targetPacked,
+                                         GLenum internalformat,
+                                         BufferID bufferPacked,
+                                         GLintptr offset,
+                                         GLsizeiptr size);
+angle::CallCapture CaptureTexParameterIiv(const State &glState,
+                                          bool isCallValid,
+                                          TextureType targetPacked,
+                                          GLenum pname,
+                                          const GLint *params);
+angle::CallCapture CaptureTexParameterIuiv(const State &glState,
+                                           bool isCallValid,
+                                           TextureType targetPacked,
+                                           GLenum pname,
+                                           const GLuint *params);
+angle::CallCapture CaptureTexStorage3DMultisample(const State &glState,
+                                                  bool isCallValid,
+                                                  TextureType targetPacked,
+                                                  GLsizei samples,
+                                                  GLenum internalformat,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLsizei depth,
+                                                  GLboolean fixedsamplelocations);
+
+// Parameter Captures
+
+void CaptureDebugMessageCallback_userParam(const State &glState,
+                                           bool isCallValid,
+                                           GLDEBUGPROC callback,
+                                           const void *userParam,
+                                           angle::ParamCapture *paramCapture);
+void CaptureDebugMessageControl_ids(const State &glState,
+                                    bool isCallValid,
+                                    GLenum source,
+                                    GLenum type,
+                                    GLenum severity,
+                                    GLsizei count,
+                                    const GLuint *ids,
+                                    GLboolean enabled,
+                                    angle::ParamCapture *paramCapture);
+void CaptureDebugMessageInsert_buf(const State &glState,
+                                   bool isCallValid,
+                                   GLenum source,
+                                   GLenum type,
+                                   GLuint id,
+                                   GLenum severity,
+                                   GLsizei length,
+                                   const GLchar *buf,
+                                   angle::ParamCapture *paramCapture);
+void CaptureDrawElementsBaseVertex_indices(const State &glState,
+                                           bool isCallValid,
+                                           PrimitiveMode modePacked,
+                                           GLsizei count,
+                                           DrawElementsType typePacked,
+                                           const void *indices,
+                                           GLint basevertex,
+                                           angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedBaseVertex_indices(const State &glState,
+                                                    bool isCallValid,
+                                                    PrimitiveMode modePacked,
+                                                    GLsizei count,
+                                                    DrawElementsType typePacked,
+                                                    const void *indices,
+                                                    GLsizei instancecount,
+                                                    GLint basevertex,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureDrawRangeElementsBaseVertex_indices(const State &glState,
+                                                bool isCallValid,
+                                                PrimitiveMode modePacked,
+                                                GLuint start,
+                                                GLuint end,
+                                                GLsizei count,
+                                                DrawElementsType typePacked,
+                                                const void *indices,
+                                                GLint basevertex,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLog_sources(const State &glState,
+                                       bool isCallValid,
+                                       GLuint count,
+                                       GLsizei bufSize,
+                                       GLenum *sources,
+                                       GLenum *types,
+                                       GLuint *ids,
+                                       GLenum *severities,
+                                       GLsizei *lengths,
+                                       GLchar *messageLog,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLog_types(const State &glState,
+                                     bool isCallValid,
+                                     GLuint count,
+                                     GLsizei bufSize,
+                                     GLenum *sources,
+                                     GLenum *types,
+                                     GLuint *ids,
+                                     GLenum *severities,
+                                     GLsizei *lengths,
+                                     GLchar *messageLog,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLog_ids(const State &glState,
+                                   bool isCallValid,
+                                   GLuint count,
+                                   GLsizei bufSize,
+                                   GLenum *sources,
+                                   GLenum *types,
+                                   GLuint *ids,
+                                   GLenum *severities,
+                                   GLsizei *lengths,
+                                   GLchar *messageLog,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLog_severities(const State &glState,
+                                          bool isCallValid,
+                                          GLuint count,
+                                          GLsizei bufSize,
+                                          GLenum *sources,
+                                          GLenum *types,
+                                          GLuint *ids,
+                                          GLenum *severities,
+                                          GLsizei *lengths,
+                                          GLchar *messageLog,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLog_lengths(const State &glState,
+                                       bool isCallValid,
+                                       GLuint count,
+                                       GLsizei bufSize,
+                                       GLenum *sources,
+                                       GLenum *types,
+                                       GLuint *ids,
+                                       GLenum *severities,
+                                       GLsizei *lengths,
+                                       GLchar *messageLog,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLog_messageLog(const State &glState,
+                                          bool isCallValid,
+                                          GLuint count,
+                                          GLsizei bufSize,
+                                          GLenum *sources,
+                                          GLenum *types,
+                                          GLuint *ids,
+                                          GLenum *severities,
+                                          GLsizei *lengths,
+                                          GLchar *messageLog,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetObjectLabel_length(const State &glState,
+                                  bool isCallValid,
+                                  GLenum identifier,
+                                  GLuint name,
+                                  GLsizei bufSize,
+                                  GLsizei *length,
+                                  GLchar *label,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetObjectLabel_label(const State &glState,
+                                 bool isCallValid,
+                                 GLenum identifier,
+                                 GLuint name,
+                                 GLsizei bufSize,
+                                 GLsizei *length,
+                                 GLchar *label,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetObjectPtrLabel_ptr(const State &glState,
+                                  bool isCallValid,
+                                  const void *ptr,
+                                  GLsizei bufSize,
+                                  GLsizei *length,
+                                  GLchar *label,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetObjectPtrLabel_length(const State &glState,
+                                     bool isCallValid,
+                                     const void *ptr,
+                                     GLsizei bufSize,
+                                     GLsizei *length,
+                                     GLchar *label,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetObjectPtrLabel_label(const State &glState,
+                                    bool isCallValid,
+                                    const void *ptr,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLchar *label,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetPointerv_params(const State &glState,
+                               bool isCallValid,
+                               GLenum pname,
+                               void **params,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIiv_params(const State &glState,
+                                          bool isCallValid,
+                                          SamplerID samplerPacked,
+                                          GLenum pname,
+                                          GLint *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIuiv_params(const State &glState,
+                                           bool isCallValid,
+                                           SamplerID samplerPacked,
+                                           GLenum pname,
+                                           GLuint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIiv_params(const State &glState,
+                                      bool isCallValid,
+                                      TextureType targetPacked,
+                                      GLenum pname,
+                                      GLint *params,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIuiv_params(const State &glState,
+                                       bool isCallValid,
+                                       TextureType targetPacked,
+                                       GLenum pname,
+                                       GLuint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetnUniformfv_params(const State &glState,
+                                 bool isCallValid,
+                                 ShaderProgramID programPacked,
+                                 UniformLocation locationPacked,
+                                 GLsizei bufSize,
+                                 GLfloat *params,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetnUniformiv_params(const State &glState,
+                                 bool isCallValid,
+                                 ShaderProgramID programPacked,
+                                 UniformLocation locationPacked,
+                                 GLsizei bufSize,
+                                 GLint *params,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetnUniformuiv_params(const State &glState,
+                                  bool isCallValid,
+                                  ShaderProgramID programPacked,
+                                  UniformLocation locationPacked,
+                                  GLsizei bufSize,
+                                  GLuint *params,
+                                  angle::ParamCapture *paramCapture);
+void CaptureObjectLabel_label(const State &glState,
+                              bool isCallValid,
+                              GLenum identifier,
+                              GLuint name,
+                              GLsizei length,
+                              const GLchar *label,
+                              angle::ParamCapture *paramCapture);
+void CaptureObjectPtrLabel_ptr(const State &glState,
+                               bool isCallValid,
+                               const void *ptr,
+                               GLsizei length,
+                               const GLchar *label,
+                               angle::ParamCapture *paramCapture);
+void CaptureObjectPtrLabel_label(const State &glState,
+                                 bool isCallValid,
+                                 const void *ptr,
+                                 GLsizei length,
+                                 const GLchar *label,
+                                 angle::ParamCapture *paramCapture);
+void CapturePushDebugGroup_message(const State &glState,
+                                   bool isCallValid,
+                                   GLenum source,
+                                   GLuint id,
+                                   GLsizei length,
+                                   const GLchar *message,
+                                   angle::ParamCapture *paramCapture);
+void CaptureReadnPixels_data(const State &glState,
+                             bool isCallValid,
+                             GLint x,
+                             GLint y,
+                             GLsizei width,
+                             GLsizei height,
+                             GLenum format,
+                             GLenum type,
+                             GLsizei bufSize,
+                             void *data,
+                             angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterIiv_param(const State &glState,
+                                      bool isCallValid,
+                                      SamplerID samplerPacked,
+                                      GLenum pname,
+                                      const GLint *param,
+                                      angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterIuiv_param(const State &glState,
+                                       bool isCallValid,
+                                       SamplerID samplerPacked,
+                                       GLenum pname,
+                                       const GLuint *param,
+                                       angle::ParamCapture *paramCapture);
+void CaptureTexParameterIiv_params(const State &glState,
+                                   bool isCallValid,
+                                   TextureType targetPacked,
+                                   GLenum pname,
+                                   const GLint *params,
+                                   angle::ParamCapture *paramCapture);
+void CaptureTexParameterIuiv_params(const State &glState,
+                                    bool isCallValid,
+                                    TextureType targetPacked,
+                                    GLenum pname,
+                                    const GLuint *params,
+                                    angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GLES_3_2_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_ext_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_ext_autogen.h
new file mode 100644
index 0000000000..ef9ed23167
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_ext_autogen.h
@@ -0,0 +1,4650 @@
+// 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"
+
+namespace gl
+{
+
+// Method Captures
+
+// GL_ANGLE_base_vertex_base_instance
+angle::CallCapture CaptureDrawArraysInstancedBaseInstanceANGLE(const State &glState,
+                                                               bool isCallValid,
+                                                               PrimitiveMode modePacked,
+                                                               GLint first,
+                                                               GLsizei count,
+                                                               GLsizei instanceCount,
+                                                               GLuint baseInstance);
+angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    GLsizei count,
+    DrawElementsType typePacked,
+    const GLvoid *indices,
+    GLsizei instanceCounts,
+    GLint baseVertex,
+    GLuint baseInstance);
+angle::CallCapture CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State &glState,
+                                                                    bool isCallValid,
+                                                                    PrimitiveMode modePacked,
+                                                                    const GLint *firsts,
+                                                                    const GLsizei *counts,
+                                                                    const GLsizei *instanceCounts,
+                                                                    const GLuint *baseInstances,
+                                                                    GLsizei drawcount);
+angle::CallCapture CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLsizei *counts,
+    DrawElementsType typePacked,
+    const GLvoid *const *indices,
+    const GLsizei *instanceCounts,
+    const GLint *baseVertices,
+    const GLuint *baseInstances,
+    GLsizei drawcount);
+
+// GL_ANGLE_copy_texture_3d
+angle::CallCapture CaptureCopyTexture3DANGLE(const State &glState,
+                                             bool isCallValid,
+                                             TextureID sourceIdPacked,
+                                             GLint sourceLevel,
+                                             TextureTarget destTargetPacked,
+                                             TextureID destIdPacked,
+                                             GLint destLevel,
+                                             GLint internalFormat,
+                                             GLenum destType,
+                                             GLboolean unpackFlipY,
+                                             GLboolean unpackPremultiplyAlpha,
+                                             GLboolean unpackUnmultiplyAlpha);
+angle::CallCapture CaptureCopySubTexture3DANGLE(const State &glState,
+                                                bool isCallValid,
+                                                TextureID sourceIdPacked,
+                                                GLint sourceLevel,
+                                                TextureTarget destTargetPacked,
+                                                TextureID destIdPacked,
+                                                GLint destLevel,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint zoffset,
+                                                GLint x,
+                                                GLint y,
+                                                GLint z,
+                                                GLint width,
+                                                GLint height,
+                                                GLint depth,
+                                                GLboolean unpackFlipY,
+                                                GLboolean unpackPremultiplyAlpha,
+                                                GLboolean unpackUnmultiplyAlpha);
+
+// GL_ANGLE_framebuffer_blit
+angle::CallCapture CaptureBlitFramebufferANGLE(const State &glState,
+                                               bool isCallValid,
+                                               GLint srcX0,
+                                               GLint srcY0,
+                                               GLint srcX1,
+                                               GLint srcY1,
+                                               GLint dstX0,
+                                               GLint dstY0,
+                                               GLint dstX1,
+                                               GLint dstY1,
+                                               GLbitfield mask,
+                                               GLenum filter);
+
+// GL_ANGLE_framebuffer_multisample
+angle::CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState,
+                                                              bool isCallValid,
+                                                              GLenum target,
+                                                              GLsizei samples,
+                                                              GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height);
+
+// GL_ANGLE_get_image
+angle::CallCapture CaptureGetTexImageANGLE(const State &glState,
+                                           bool isCallValid,
+                                           TextureTarget targetPacked,
+                                           GLint level,
+                                           GLenum format,
+                                           GLenum type,
+                                           void *pixels);
+angle::CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum target,
+                                                    GLenum format,
+                                                    GLenum type,
+                                                    void *pixels);
+
+// GL_ANGLE_get_tex_level_parameter
+angle::CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState,
+                                                      bool isCallValid,
+                                                      TextureTarget targetPacked,
+                                                      GLint level,
+                                                      GLenum pname,
+                                                      GLint *params);
+angle::CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState,
+                                                      bool isCallValid,
+                                                      TextureTarget targetPacked,
+                                                      GLint level,
+                                                      GLenum pname,
+                                                      GLfloat *params);
+
+// GL_ANGLE_instanced_arrays
+angle::CallCapture CaptureDrawArraysInstancedANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   PrimitiveMode modePacked,
+                                                   GLint first,
+                                                   GLsizei count,
+                                                   GLsizei primcount);
+angle::CallCapture CaptureDrawElementsInstancedANGLE(const State &glState,
+                                                     bool isCallValid,
+                                                     PrimitiveMode modePacked,
+                                                     GLsizei count,
+                                                     DrawElementsType typePacked,
+                                                     const void *indices,
+                                                     GLsizei primcount);
+angle::CallCapture CaptureVertexAttribDivisorANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   GLuint index,
+                                                   GLuint divisor);
+
+// GL_ANGLE_memory_object_flags
+angle::CallCapture CaptureTexStorageMemFlags2DANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureType targetPacked,
+                                                    GLsizei levels,
+                                                    GLenum internalFormat,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    MemoryObjectID memoryPacked,
+                                                    GLuint64 offset,
+                                                    GLbitfield createFlags,
+                                                    GLbitfield usageFlags);
+angle::CallCapture CaptureTexStorageMemFlags2DMultisampleANGLE(const State &glState,
+                                                               bool isCallValid,
+                                                               TextureType targetPacked,
+                                                               GLsizei samples,
+                                                               GLenum internalFormat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               GLboolean fixedSampleLocations,
+                                                               MemoryObjectID memoryPacked,
+                                                               GLuint64 offset,
+                                                               GLbitfield createFlags,
+                                                               GLbitfield usageFlags);
+angle::CallCapture CaptureTexStorageMemFlags3DANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureType targetPacked,
+                                                    GLsizei levels,
+                                                    GLenum internalFormat,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLsizei depth,
+                                                    MemoryObjectID memoryPacked,
+                                                    GLuint64 offset,
+                                                    GLbitfield createFlags,
+                                                    GLbitfield usageFlags);
+angle::CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState,
+                                                               bool isCallValid,
+                                                               TextureType targetPacked,
+                                                               GLsizei samples,
+                                                               GLenum internalFormat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               GLsizei depth,
+                                                               GLboolean fixedSampleLocations,
+                                                               MemoryObjectID memoryPacked,
+                                                               GLuint64 offset,
+                                                               GLbitfield createFlags,
+                                                               GLbitfield usageFlags);
+
+// GL_ANGLE_memory_object_fuchsia
+angle::CallCapture CaptureImportMemoryZirconHandleANGLE(const State &glState,
+                                                        bool isCallValid,
+                                                        MemoryObjectID memoryPacked,
+                                                        GLuint64 size,
+                                                        HandleType handleTypePacked,
+                                                        GLuint handle);
+
+// GL_ANGLE_multi_draw
+angle::CallCapture CaptureMultiDrawArraysANGLE(const State &glState,
+                                               bool isCallValid,
+                                               PrimitiveMode modePacked,
+                                               const GLint *firsts,
+                                               const GLsizei *counts,
+                                               GLsizei drawcount);
+angle::CallCapture CaptureMultiDrawArraysInstancedANGLE(const State &glState,
+                                                        bool isCallValid,
+                                                        PrimitiveMode modePacked,
+                                                        const GLint *firsts,
+                                                        const GLsizei *counts,
+                                                        const GLsizei *instanceCounts,
+                                                        GLsizei drawcount);
+angle::CallCapture CaptureMultiDrawElementsANGLE(const State &glState,
+                                                 bool isCallValid,
+                                                 PrimitiveMode modePacked,
+                                                 const GLsizei *counts,
+                                                 DrawElementsType typePacked,
+                                                 const GLvoid *const *indices,
+                                                 GLsizei drawcount);
+angle::CallCapture CaptureMultiDrawElementsInstancedANGLE(const State &glState,
+                                                          bool isCallValid,
+                                                          PrimitiveMode modePacked,
+                                                          const GLsizei *counts,
+                                                          DrawElementsType typePacked,
+                                                          const GLvoid *const *indices,
+                                                          const GLsizei *instanceCounts,
+                                                          GLsizei drawcount);
+
+// GL_ANGLE_program_binary
+
+// GL_ANGLE_provoking_vertex
+angle::CallCapture CaptureProvokingVertexANGLE(const State &glState,
+                                               bool isCallValid,
+                                               ProvokingVertexConvention modePacked);
+
+// GL_ANGLE_request_extension
+angle::CallCapture CaptureRequestExtensionANGLE(const State &glState,
+                                                bool isCallValid,
+                                                const GLchar *name);
+angle::CallCapture CaptureDisableExtensionANGLE(const State &glState,
+                                                bool isCallValid,
+                                                const GLchar *name);
+
+// GL_ANGLE_robust_client_memory
+angle::CallCapture CaptureGetBooleanvRobustANGLE(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLboolean *params);
+angle::CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState,
+                                                          bool isCallValid,
+                                                          BufferBinding targetPacked,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLint *params);
+angle::CallCapture CaptureGetFloatvRobustANGLE(const State &glState,
+                                               bool isCallValid,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLfloat *params);
+angle::CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState,
+                                                                         bool isCallValid,
+                                                                         GLenum target,
+                                                                         GLenum attachment,
+                                                                         GLenum pname,
+                                                                         GLsizei bufSize,
+                                                                         GLsizei *length,
+                                                                         GLint *params);
+angle::CallCapture CaptureGetIntegervRobustANGLE(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *data);
+angle::CallCapture CaptureGetProgramivRobustANGLE(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLint *params);
+angle::CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState,
+                                                                bool isCallValid,
+                                                                GLenum target,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint *params);
+angle::CallCapture CaptureGetShaderivRobustANGLE(const State &glState,
+                                                 bool isCallValid,
+                                                 ShaderProgramID shaderPacked,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *params);
+angle::CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState,
+                                                       bool isCallValid,
+                                                       TextureType targetPacked,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLfloat *params);
+angle::CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState,
+                                                       bool isCallValid,
+                                                       TextureType targetPacked,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLint *params);
+angle::CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformLocation locationPacked,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLfloat *params);
+angle::CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformLocation locationPacked,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLint *params);
+angle::CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState,
+                                                       bool isCallValid,
+                                                       GLuint index,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLfloat *params);
+angle::CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState,
+                                                       bool isCallValid,
+                                                       GLuint index,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLint *params);
+angle::CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState,
+                                                             bool isCallValid,
+                                                             GLuint index,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             void **pointer);
+angle::CallCapture CaptureReadPixelsRobustANGLE(const State &glState,
+                                                bool isCallValid,
+                                                GLint x,
+                                                GLint y,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLenum format,
+                                                GLenum type,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLsizei *columns,
+                                                GLsizei *rows,
+                                                void *pixels);
+angle::CallCapture CaptureTexImage2DRobustANGLE(const State &glState,
+                                                bool isCallValid,
+                                                TextureTarget targetPacked,
+                                                GLint level,
+                                                GLint internalformat,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLint border,
+                                                GLenum format,
+                                                GLenum type,
+                                                GLsizei bufSize,
+                                                const void *pixels);
+angle::CallCapture CaptureTexParameterfvRobustANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureType targetPacked,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    const GLfloat *params);
+angle::CallCapture CaptureTexParameterivRobustANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureType targetPacked,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    const GLint *params);
+angle::CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   TextureTarget targetPacked,
+                                                   GLint level,
+                                                   GLint xoffset,
+                                                   GLint yoffset,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLenum format,
+                                                   GLenum type,
+                                                   GLsizei bufSize,
+                                                   const void *pixels);
+angle::CallCapture CaptureTexImage3DRobustANGLE(const State &glState,
+                                                bool isCallValid,
+                                                TextureTarget targetPacked,
+                                                GLint level,
+                                                GLint internalformat,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLsizei depth,
+                                                GLint border,
+                                                GLenum format,
+                                                GLenum type,
+                                                GLsizei bufSize,
+                                                const void *pixels);
+angle::CallCapture CaptureTexSubImage3DRobustANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   TextureTarget targetPacked,
+                                                   GLint level,
+                                                   GLint xoffset,
+                                                   GLint yoffset,
+                                                   GLint zoffset,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLsizei depth,
+                                                   GLenum format,
+                                                   GLenum type,
+                                                   GLsizei bufSize,
+                                                   const void *pixels);
+angle::CallCapture CaptureCompressedTexImage2DRobustANGLE(const State &glState,
+                                                          bool isCallValid,
+                                                          TextureTarget targetPacked,
+                                                          GLint level,
+                                                          GLenum internalformat,
+                                                          GLsizei width,
+                                                          GLsizei height,
+                                                          GLint border,
+                                                          GLsizei imageSize,
+                                                          GLsizei dataSize,
+                                                          const GLvoid *data);
+angle::CallCapture CaptureCompressedTexSubImage2DRobustANGLE(const State &glState,
+                                                             bool isCallValid,
+                                                             TextureTarget targetPacked,
+                                                             GLint level,
+                                                             GLsizei xoffset,
+                                                             GLsizei yoffset,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             GLenum format,
+                                                             GLsizei imageSize,
+                                                             GLsizei dataSize,
+                                                             const GLvoid *data);
+angle::CallCapture CaptureCompressedTexImage3DRobustANGLE(const State &glState,
+                                                          bool isCallValid,
+                                                          TextureTarget targetPacked,
+                                                          GLint level,
+                                                          GLenum internalformat,
+                                                          GLsizei width,
+                                                          GLsizei height,
+                                                          GLsizei depth,
+                                                          GLint border,
+                                                          GLsizei imageSize,
+                                                          GLsizei dataSize,
+                                                          const GLvoid *data);
+angle::CallCapture CaptureCompressedTexSubImage3DRobustANGLE(const State &glState,
+                                                             bool isCallValid,
+                                                             TextureTarget targetPacked,
+                                                             GLint level,
+                                                             GLint xoffset,
+                                                             GLint yoffset,
+                                                             GLint zoffset,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             GLsizei depth,
+                                                             GLenum format,
+                                                             GLsizei imageSize,
+                                                             GLsizei dataSize,
+                                                             const GLvoid *data);
+angle::CallCapture CaptureGetQueryivRobustANGLE(const State &glState,
+                                                bool isCallValid,
+                                                QueryType targetPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *params);
+angle::CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState,
+                                                       bool isCallValid,
+                                                       QueryID idPacked,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLuint *params);
+angle::CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState,
+                                                       bool isCallValid,
+                                                       BufferBinding targetPacked,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       void **params);
+angle::CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   GLenum target,
+                                                   GLuint index,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *data);
+angle::CallCapture CaptureGetInternalformativRobustANGLE(const State &glState,
+                                                         bool isCallValid,
+                                                         GLenum target,
+                                                         GLenum internalformat,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLint *params);
+angle::CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState,
+                                                        bool isCallValid,
+                                                        GLuint index,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint *params);
+angle::CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState,
+                                                         bool isCallValid,
+                                                         GLuint index,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLuint *params);
+angle::CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   ShaderProgramID programPacked,
+                                                   UniformLocation locationPacked,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLuint *params);
+angle::CallCapture CaptureGetActiveUniformBlockivRobustANGLE(
+    const State &glState,
+    bool isCallValid,
+    ShaderProgramID programPacked,
+    UniformBlockIndex uniformBlockIndexPacked,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei *length,
+    GLint *params);
+angle::CallCapture CaptureGetInteger64vRobustANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint64 *data);
+angle::CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState,
+                                                     bool isCallValid,
+                                                     GLenum target,
+                                                     GLuint index,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint64 *data);
+angle::CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState,
+                                                            bool isCallValid,
+                                                            BufferBinding targetPacked,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint64 *params);
+angle::CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState,
+                                                        bool isCallValid,
+                                                        SamplerID samplerPacked,
+                                                        GLuint pname,
+                                                        GLsizei bufSize,
+                                                        const GLint *param);
+angle::CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState,
+                                                        bool isCallValid,
+                                                        SamplerID samplerPacked,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        const GLfloat *param);
+angle::CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState,
+                                                           bool isCallValid,
+                                                           SamplerID samplerPacked,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *params);
+angle::CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState,
+                                                           bool isCallValid,
+                                                           SamplerID samplerPacked,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLfloat *params);
+angle::CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState,
+                                                               bool isCallValid,
+                                                               GLenum target,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLint *params);
+angle::CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState,
+                                                           bool isCallValid,
+                                                           ShaderProgramID programPacked,
+                                                           GLenum programInterface,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *params);
+angle::CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   GLenum target,
+                                                   GLuint index,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLboolean *data);
+angle::CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState,
+                                                      bool isCallValid,
+                                                      GLenum pname,
+                                                      GLuint index,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLfloat *val);
+angle::CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState,
+                                                            bool isCallValid,
+                                                            TextureTarget targetPacked,
+                                                            GLint level,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint *params);
+angle::CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState,
+                                                            bool isCallValid,
+                                                            TextureTarget targetPacked,
+                                                            GLint level,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLfloat *params);
+angle::CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState,
+                                                            bool isCallValid,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            void **params);
+angle::CallCapture CaptureReadnPixelsRobustANGLE(const State &glState,
+                                                 bool isCallValid,
+                                                 GLint x,
+                                                 GLint y,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLenum format,
+                                                 GLenum type,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLsizei *columns,
+                                                 GLsizei *rows,
+                                                 void *data);
+angle::CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   ShaderProgramID programPacked,
+                                                   UniformLocation locationPacked,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLfloat *params);
+angle::CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
+                                                   bool isCallValid,
+                                                   ShaderProgramID programPacked,
+                                                   UniformLocation locationPacked,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *params);
+angle::CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLuint *params);
+angle::CallCapture CaptureTexParameterIivRobustANGLE(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureType targetPacked,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     const GLint *params);
+angle::CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState,
+                                                      bool isCallValid,
+                                                      TextureType targetPacked,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      const GLuint *params);
+angle::CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState,
+                                                        bool isCallValid,
+                                                        TextureType targetPacked,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint *params);
+angle::CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState,
+                                                         bool isCallValid,
+                                                         TextureType targetPacked,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLuint *params);
+angle::CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState,
+                                                         bool isCallValid,
+                                                         SamplerID samplerPacked,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         const GLint *param);
+angle::CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState,
+                                                          bool isCallValid,
+                                                          SamplerID samplerPacked,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          const GLuint *param);
+angle::CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState,
+                                                            bool isCallValid,
+                                                            SamplerID samplerPacked,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint *params);
+angle::CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState,
+                                                             bool isCallValid,
+                                                             SamplerID samplerPacked,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLuint *params);
+angle::CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState,
+                                                      bool isCallValid,
+                                                      QueryID idPacked,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params);
+angle::CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState,
+                                                        bool isCallValid,
+                                                        QueryID idPacked,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint64 *params);
+angle::CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState,
+                                                         bool isCallValid,
+                                                         QueryID idPacked,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLuint64 *params);
+
+// GL_ANGLE_semaphore_fuchsia
+angle::CallCapture CaptureImportSemaphoreZirconHandleANGLE(const State &glState,
+                                                           bool isCallValid,
+                                                           SemaphoreID semaphorePacked,
+                                                           HandleType handleTypePacked,
+                                                           GLuint handle);
+
+// GL_ANGLE_texture_external_update
+angle::CallCapture CaptureTexImage2DExternalANGLE(const State &glState,
+                                                  bool isCallValid,
+                                                  TextureTarget targetPacked,
+                                                  GLint level,
+                                                  GLint internalformat,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLint border,
+                                                  GLenum format,
+                                                  GLenum type);
+angle::CallCapture CaptureInvalidateTextureANGLE(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureType targetPacked);
+
+// GL_ANGLE_texture_multisample
+angle::CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState,
+                                                       bool isCallValid,
+                                                       TextureType targetPacked,
+                                                       GLsizei samples,
+                                                       GLenum internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLboolean fixedsamplelocations);
+angle::CallCapture CaptureGetMultisamplefvANGLE(const State &glState,
+                                                bool isCallValid,
+                                                GLenum pname,
+                                                GLuint index,
+                                                GLfloat *val);
+angle::CallCapture CaptureSampleMaskiANGLE(const State &glState,
+                                           bool isCallValid,
+                                           GLuint maskNumber,
+                                           GLbitfield mask);
+
+// GL_ANGLE_translated_shader_source
+angle::CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
+                                                         bool isCallValid,
+                                                         ShaderProgramID shaderPacked,
+                                                         GLsizei bufsize,
+                                                         GLsizei *length,
+                                                         GLchar *source);
+
+// GL_CHROMIUM_bind_uniform_location
+angle::CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
+                                                      bool isCallValid,
+                                                      ShaderProgramID programPacked,
+                                                      UniformLocation locationPacked,
+                                                      const GLchar *name);
+
+// GL_CHROMIUM_copy_compressed_texture
+angle::CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState,
+                                                        bool isCallValid,
+                                                        TextureID sourceIdPacked,
+                                                        TextureID destIdPacked);
+
+// GL_CHROMIUM_copy_texture
+angle::CallCapture CaptureCopyTextureCHROMIUM(const State &glState,
+                                              bool isCallValid,
+                                              TextureID sourceIdPacked,
+                                              GLint sourceLevel,
+                                              TextureTarget destTargetPacked,
+                                              TextureID destIdPacked,
+                                              GLint destLevel,
+                                              GLint internalFormat,
+                                              GLenum destType,
+                                              GLboolean unpackFlipY,
+                                              GLboolean unpackPremultiplyAlpha,
+                                              GLboolean unpackUnmultiplyAlpha);
+angle::CallCapture CaptureCopySubTextureCHROMIUM(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureID sourceIdPacked,
+                                                 GLint sourceLevel,
+                                                 TextureTarget destTargetPacked,
+                                                 TextureID destIdPacked,
+                                                 GLint destLevel,
+                                                 GLint xoffset,
+                                                 GLint yoffset,
+                                                 GLint x,
+                                                 GLint y,
+                                                 GLint width,
+                                                 GLint height,
+                                                 GLboolean unpackFlipY,
+                                                 GLboolean unpackPremultiplyAlpha,
+                                                 GLboolean unpackUnmultiplyAlpha);
+
+// GL_CHROMIUM_framebuffer_mixed_samples
+angle::CallCapture CaptureCoverageModulationCHROMIUM(const State &glState,
+                                                     bool isCallValid,
+                                                     GLenum components);
+
+// GL_CHROMIUM_lose_context
+angle::CallCapture CaptureLoseContextCHROMIUM(const State &glState,
+                                              bool isCallValid,
+                                              GraphicsResetStatus currentPacked,
+                                              GraphicsResetStatus otherPacked);
+
+// GL_EXT_EGL_image_array
+
+// GL_EXT_YUV_target
+
+// GL_EXT_blend_func_extended
+angle::CallCapture CaptureBindFragDataLocationEXT(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  GLuint color,
+                                                  const GLchar *name);
+angle::CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState,
+                                                         bool isCallValid,
+                                                         ShaderProgramID programPacked,
+                                                         GLuint colorNumber,
+                                                         GLuint index,
+                                                         const GLchar *name);
+angle::CallCapture CaptureGetFragDataIndexEXT(const State &glState,
+                                              bool isCallValid,
+                                              ShaderProgramID programPacked,
+                                              const GLchar *name,
+                                              GLint returnValue);
+angle::CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState,
+                                                             bool isCallValid,
+                                                             ShaderProgramID programPacked,
+                                                             GLenum programInterface,
+                                                             const GLchar *name,
+                                                             GLint returnValue);
+
+// GL_EXT_buffer_storage
+angle::CallCapture CaptureBufferStorageEXT(const State &glState,
+                                           bool isCallValid,
+                                           BufferBinding targetPacked,
+                                           GLsizeiptr size,
+                                           const void *data,
+                                           GLbitfield flags);
+
+// GL_EXT_clip_control
+angle::CallCapture CaptureClipControlEXT(const State &glState,
+                                         bool isCallValid,
+                                         GLenum origin,
+                                         GLenum 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_discard_framebuffer
+angle::CallCapture CaptureDiscardFramebufferEXT(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLsizei numAttachments,
+                                                const GLenum *attachments);
+
+// GL_EXT_disjoint_timer_query
+angle::CallCapture CaptureBeginQueryEXT(const State &glState,
+                                        bool isCallValid,
+                                        QueryType targetPacked,
+                                        QueryID idPacked);
+angle::CallCapture CaptureDeleteQueriesEXT(const State &glState,
+                                           bool isCallValid,
+                                           GLsizei n,
+                                           const QueryID *idsPacked);
+angle::CallCapture CaptureEndQueryEXT(const State &glState,
+                                      bool isCallValid,
+                                      QueryType targetPacked);
+angle::CallCapture CaptureGenQueriesEXT(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        QueryID *idsPacked);
+angle::CallCapture CaptureGetInteger64vEXT(const State &glState,
+                                           bool isCallValid,
+                                           GLenum pname,
+                                           GLint64 *data);
+angle::CallCapture CaptureGetQueryObjecti64vEXT(const State &glState,
+                                                bool isCallValid,
+                                                QueryID idPacked,
+                                                GLenum pname,
+                                                GLint64 *params);
+angle::CallCapture CaptureGetQueryObjectivEXT(const State &glState,
+                                              bool isCallValid,
+                                              QueryID idPacked,
+                                              GLenum pname,
+                                              GLint *params);
+angle::CallCapture CaptureGetQueryObjectui64vEXT(const State &glState,
+                                                 bool isCallValid,
+                                                 QueryID idPacked,
+                                                 GLenum pname,
+                                                 GLuint64 *params);
+angle::CallCapture CaptureGetQueryObjectuivEXT(const State &glState,
+                                               bool isCallValid,
+                                               QueryID idPacked,
+                                               GLenum pname,
+                                               GLuint *params);
+angle::CallCapture CaptureGetQueryivEXT(const State &glState,
+                                        bool isCallValid,
+                                        QueryType targetPacked,
+                                        GLenum pname,
+                                        GLint *params);
+angle::CallCapture CaptureIsQueryEXT(const State &glState,
+                                     bool isCallValid,
+                                     QueryID idPacked,
+                                     GLboolean returnValue);
+angle::CallCapture CaptureQueryCounterEXT(const State &glState,
+                                          bool isCallValid,
+                                          QueryID idPacked,
+                                          QueryType targetPacked);
+
+// GL_EXT_draw_buffers
+angle::CallCapture CaptureDrawBuffersEXT(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei n,
+                                         const GLenum *bufs);
+
+// GL_EXT_draw_buffers_indexed
+angle::CallCapture CaptureBlendEquationSeparateiEXT(const State &glState,
+                                                    bool isCallValid,
+                                                    GLuint buf,
+                                                    GLenum modeRGB,
+                                                    GLenum modeAlpha);
+angle::CallCapture CaptureBlendEquationiEXT(const State &glState,
+                                            bool isCallValid,
+                                            GLuint buf,
+                                            GLenum mode);
+angle::CallCapture CaptureBlendFuncSeparateiEXT(const State &glState,
+                                                bool isCallValid,
+                                                GLuint buf,
+                                                GLenum srcRGB,
+                                                GLenum dstRGB,
+                                                GLenum srcAlpha,
+                                                GLenum dstAlpha);
+angle::CallCapture CaptureBlendFunciEXT(const State &glState,
+                                        bool isCallValid,
+                                        GLuint buf,
+                                        GLenum src,
+                                        GLenum dst);
+angle::CallCapture CaptureColorMaskiEXT(const State &glState,
+                                        bool isCallValid,
+                                        GLuint index,
+                                        GLboolean r,
+                                        GLboolean g,
+                                        GLboolean b,
+                                        GLboolean a);
+angle::CallCapture CaptureDisableiEXT(const State &glState,
+                                      bool isCallValid,
+                                      GLenum target,
+                                      GLuint index);
+angle::CallCapture CaptureEnableiEXT(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLuint index);
+angle::CallCapture CaptureIsEnablediEXT(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLuint index,
+                                        GLboolean returnValue);
+
+// GL_EXT_draw_elements_base_vertex
+angle::CallCapture CaptureDrawElementsBaseVertexEXT(const State &glState,
+                                                    bool isCallValid,
+                                                    PrimitiveMode modePacked,
+                                                    GLsizei count,
+                                                    DrawElementsType typePacked,
+                                                    const void *indices,
+                                                    GLint basevertex);
+angle::CallCapture CaptureDrawElementsInstancedBaseVertexEXT(const State &glState,
+                                                             bool isCallValid,
+                                                             PrimitiveMode modePacked,
+                                                             GLsizei count,
+                                                             DrawElementsType typePacked,
+                                                             const void *indices,
+                                                             GLsizei instancecount,
+                                                             GLint basevertex);
+angle::CallCapture CaptureDrawRangeElementsBaseVertexEXT(const State &glState,
+                                                         bool isCallValid,
+                                                         PrimitiveMode modePacked,
+                                                         GLuint start,
+                                                         GLuint end,
+                                                         GLsizei count,
+                                                         DrawElementsType typePacked,
+                                                         const void *indices,
+                                                         GLint basevertex);
+angle::CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState,
+                                                         bool isCallValid,
+                                                         PrimitiveMode modePacked,
+                                                         const GLsizei *count,
+                                                         DrawElementsType typePacked,
+                                                         const void *const *indices,
+                                                         GLsizei primcount,
+                                                         const GLint *basevertex);
+
+// GL_EXT_external_buffer
+angle::CallCapture CaptureBufferStorageExternalEXT(const State &glState,
+                                                   bool isCallValid,
+                                                   BufferBinding targetPacked,
+                                                   GLintptr offset,
+                                                   GLsizeiptr size,
+                                                   GLeglClientBufferEXT clientBuffer,
+                                                   GLbitfield flags);
+angle::CallCapture CaptureNamedBufferStorageExternalEXT(const State &glState,
+                                                        bool isCallValid,
+                                                        GLuint buffer,
+                                                        GLintptr offset,
+                                                        GLsizeiptr size,
+                                                        GLeglClientBufferEXT clientBuffer,
+                                                        GLbitfield flags);
+
+// GL_EXT_geometry_shader
+angle::CallCapture CaptureFramebufferTextureEXT(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLenum attachment,
+                                                TextureID texturePacked,
+                                                GLint level);
+
+// GL_EXT_instanced_arrays
+angle::CallCapture CaptureDrawArraysInstancedEXT(const State &glState,
+                                                 bool isCallValid,
+                                                 PrimitiveMode modePacked,
+                                                 GLint start,
+                                                 GLsizei count,
+                                                 GLsizei primcount);
+angle::CallCapture CaptureDrawElementsInstancedEXT(const State &glState,
+                                                   bool isCallValid,
+                                                   PrimitiveMode modePacked,
+                                                   GLsizei count,
+                                                   DrawElementsType typePacked,
+                                                   const void *indices,
+                                                   GLsizei primcount);
+angle::CallCapture CaptureVertexAttribDivisorEXT(const State &glState,
+                                                 bool isCallValid,
+                                                 GLuint index,
+                                                 GLuint divisor);
+
+// GL_EXT_map_buffer_range
+angle::CallCapture CaptureFlushMappedBufferRangeEXT(const State &glState,
+                                                    bool isCallValid,
+                                                    BufferBinding targetPacked,
+                                                    GLintptr offset,
+                                                    GLsizeiptr length);
+angle::CallCapture CaptureMapBufferRangeEXT(const State &glState,
+                                            bool isCallValid,
+                                            BufferBinding targetPacked,
+                                            GLintptr offset,
+                                            GLsizeiptr length,
+                                            GLbitfield access,
+                                            void *returnValue);
+
+// GL_EXT_memory_object
+angle::CallCapture CaptureBufferStorageMemEXT(const State &glState,
+                                              bool isCallValid,
+                                              TextureType targetPacked,
+                                              GLsizeiptr size,
+                                              MemoryObjectID memoryPacked,
+                                              GLuint64 offset);
+angle::CallCapture CaptureCreateMemoryObjectsEXT(const State &glState,
+                                                 bool isCallValid,
+                                                 GLsizei n,
+                                                 MemoryObjectID *memoryObjectsPacked);
+angle::CallCapture CaptureDeleteMemoryObjectsEXT(const State &glState,
+                                                 bool isCallValid,
+                                                 GLsizei n,
+                                                 const MemoryObjectID *memoryObjectsPacked);
+angle::CallCapture CaptureGetMemoryObjectParameterivEXT(const State &glState,
+                                                        bool isCallValid,
+                                                        MemoryObjectID memoryObjectPacked,
+                                                        GLenum pname,
+                                                        GLint *params);
+angle::CallCapture CaptureGetUnsignedBytevEXT(const State &glState,
+                                              bool isCallValid,
+                                              GLenum pname,
+                                              GLubyte *data);
+angle::CallCapture CaptureGetUnsignedBytei_vEXT(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLuint index,
+                                                GLubyte *data);
+angle::CallCapture CaptureIsMemoryObjectEXT(const State &glState,
+                                            bool isCallValid,
+                                            MemoryObjectID memoryObjectPacked,
+                                            GLboolean returnValue);
+angle::CallCapture CaptureMemoryObjectParameterivEXT(const State &glState,
+                                                     bool isCallValid,
+                                                     MemoryObjectID memoryObjectPacked,
+                                                     GLenum pname,
+                                                     const GLint *params);
+angle::CallCapture CaptureTexStorageMem2DEXT(const State &glState,
+                                             bool isCallValid,
+                                             TextureType targetPacked,
+                                             GLsizei levels,
+                                             GLenum internalFormat,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             MemoryObjectID memoryPacked,
+                                             GLuint64 offset);
+angle::CallCapture CaptureTexStorageMem2DMultisampleEXT(const State &glState,
+                                                        bool isCallValid,
+                                                        TextureType targetPacked,
+                                                        GLsizei samples,
+                                                        GLenum internalFormat,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLboolean fixedSampleLocations,
+                                                        MemoryObjectID memoryPacked,
+                                                        GLuint64 offset);
+angle::CallCapture CaptureTexStorageMem3DEXT(const State &glState,
+                                             bool isCallValid,
+                                             TextureType targetPacked,
+                                             GLsizei levels,
+                                             GLenum internalFormat,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLsizei depth,
+                                             MemoryObjectID memoryPacked,
+                                             GLuint64 offset);
+angle::CallCapture CaptureTexStorageMem3DMultisampleEXT(const State &glState,
+                                                        bool isCallValid,
+                                                        TextureType targetPacked,
+                                                        GLsizei samples,
+                                                        GLenum internalFormat,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLsizei depth,
+                                                        GLboolean fixedSampleLocations,
+                                                        MemoryObjectID memoryPacked,
+                                                        GLuint64 offset);
+
+// GL_EXT_memory_object_fd
+angle::CallCapture CaptureImportMemoryFdEXT(const State &glState,
+                                            bool isCallValid,
+                                            MemoryObjectID memoryPacked,
+                                            GLuint64 size,
+                                            HandleType handleTypePacked,
+                                            GLint fd);
+
+// GL_EXT_multisampled_render_to_texture
+angle::CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState,
+                                                             bool isCallValid,
+                                                             GLenum target,
+                                                             GLenum attachment,
+                                                             TextureTarget textargetPacked,
+                                                             TextureID texturePacked,
+                                                             GLint level,
+                                                             GLsizei samples);
+angle::CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState,
+                                                            bool isCallValid,
+                                                            GLenum target,
+                                                            GLsizei samples,
+                                                            GLenum internalformat,
+                                                            GLsizei width,
+                                                            GLsizei height);
+
+// GL_EXT_occlusion_query_boolean
+
+// GL_EXT_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_read_format_bgra
+
+// GL_EXT_robustness
+angle::CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum returnValue);
+angle::CallCapture CaptureGetnUniformfvEXT(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLsizei bufSize,
+                                           GLfloat *params);
+angle::CallCapture CaptureGetnUniformivEXT(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLsizei bufSize,
+                                           GLint *params);
+angle::CallCapture CaptureReadnPixelsEXT(const State &glState,
+                                         bool isCallValid,
+                                         GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         void *data);
+
+// GL_EXT_sRGB
+
+// GL_EXT_semaphore
+angle::CallCapture CaptureDeleteSemaphoresEXT(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              const SemaphoreID *semaphoresPacked);
+angle::CallCapture CaptureGenSemaphoresEXT(const State &glState,
+                                           bool isCallValid,
+                                           GLsizei n,
+                                           SemaphoreID *semaphoresPacked);
+angle::CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState,
+                                                        bool isCallValid,
+                                                        SemaphoreID semaphorePacked,
+                                                        GLenum pname,
+                                                        GLuint64 *params);
+angle::CallCapture CaptureIsSemaphoreEXT(const State &glState,
+                                         bool isCallValid,
+                                         SemaphoreID semaphorePacked,
+                                         GLboolean returnValue);
+angle::CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState,
+                                                     bool isCallValid,
+                                                     SemaphoreID semaphorePacked,
+                                                     GLenum pname,
+                                                     const GLuint64 *params);
+angle::CallCapture CaptureSignalSemaphoreEXT(const State &glState,
+                                             bool isCallValid,
+                                             SemaphoreID semaphorePacked,
+                                             GLuint numBufferBarriers,
+                                             const BufferID *buffersPacked,
+                                             GLuint numTextureBarriers,
+                                             const TextureID *texturesPacked,
+                                             const GLenum *dstLayouts);
+angle::CallCapture CaptureWaitSemaphoreEXT(const State &glState,
+                                           bool isCallValid,
+                                           SemaphoreID semaphorePacked,
+                                           GLuint numBufferBarriers,
+                                           const BufferID *buffersPacked,
+                                           GLuint numTextureBarriers,
+                                           const TextureID *texturesPacked,
+                                           const GLenum *srcLayouts);
+
+// GL_EXT_semaphore_fd
+angle::CallCapture CaptureImportSemaphoreFdEXT(const State &glState,
+                                               bool isCallValid,
+                                               SemaphoreID semaphorePacked,
+                                               HandleType handleTypePacked,
+                                               GLint fd);
+
+// GL_EXT_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 **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_non_coherent
+angle::CallCapture CaptureFramebufferFetchBarrierEXT(const State &glState, bool isCallValid);
+
+// GL_EXT_shader_io_blocks
+
+// 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,
+                                                    GLenum pname,
+                                                    GLint *params);
+angle::CallCapture CaptureGetSamplerParameterIuivEXT(const State &glState,
+                                                     bool isCallValid,
+                                                     SamplerID samplerPacked,
+                                                     GLenum pname,
+                                                     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,
+                                                 GLenum pname,
+                                                 const GLint *param);
+angle::CallCapture CaptureSamplerParameterIuivEXT(const State &glState,
+                                                  bool isCallValid,
+                                                  SamplerID samplerPacked,
+                                                  GLenum pname,
+                                                  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_bptc
+
+// GL_EXT_texture_compression_dxt1
+
+// GL_EXT_texture_compression_rgtc
+
+// GL_EXT_texture_compression_s3tc
+
+// GL_EXT_texture_compression_s3tc_srgb
+
+// GL_EXT_texture_cube_map_array
+
+// GL_EXT_texture_filter_anisotropic
+
+// GL_EXT_texture_format_BGRA8888
+
+// GL_EXT_texture_sRGB_R8
+
+// GL_EXT_texture_sRGB_RG8
+
+// GL_EXT_texture_storage
+angle::CallCapture CaptureTexStorage1DEXT(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLsizei levels,
+                                          GLenum internalformat,
+                                          GLsizei width);
+angle::CallCapture CaptureTexStorage2DEXT(const State &glState,
+                                          bool isCallValid,
+                                          TextureType targetPacked,
+                                          GLsizei levels,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height);
+angle::CallCapture CaptureTexStorage3DEXT(const State &glState,
+                                          bool isCallValid,
+                                          TextureType targetPacked,
+                                          GLsizei levels,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLsizei depth);
+
+// GL_KHR_blend_equation_advanced
+angle::CallCapture CaptureBlendBarrierKHR(const State &glState, bool isCallValid);
+
+// GL_KHR_debug
+angle::CallCapture CaptureDebugMessageCallbackKHR(const State &glState,
+                                                  bool isCallValid,
+                                                  GLDEBUGPROCKHR callback,
+                                                  const void *userParam);
+angle::CallCapture CaptureDebugMessageControlKHR(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum source,
+                                                 GLenum type,
+                                                 GLenum severity,
+                                                 GLsizei count,
+                                                 const GLuint *ids,
+                                                 GLboolean enabled);
+angle::CallCapture CaptureDebugMessageInsertKHR(const State &glState,
+                                                bool isCallValid,
+                                                GLenum source,
+                                                GLenum type,
+                                                GLuint id,
+                                                GLenum severity,
+                                                GLsizei length,
+                                                const GLchar *buf);
+angle::CallCapture CaptureGetDebugMessageLogKHR(const State &glState,
+                                                bool isCallValid,
+                                                GLuint count,
+                                                GLsizei bufSize,
+                                                GLenum *sources,
+                                                GLenum *types,
+                                                GLuint *ids,
+                                                GLenum *severities,
+                                                GLsizei *lengths,
+                                                GLchar *messageLog,
+                                                GLuint returnValue);
+angle::CallCapture CaptureGetObjectLabelKHR(const State &glState,
+                                            bool isCallValid,
+                                            GLenum identifier,
+                                            GLuint name,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLchar *label);
+angle::CallCapture CaptureGetObjectPtrLabelKHR(const State &glState,
+                                               bool isCallValid,
+                                               const void *ptr,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLchar *label);
+angle::CallCapture CaptureGetPointervKHR(const State &glState,
+                                         bool isCallValid,
+                                         GLenum pname,
+                                         void **params);
+angle::CallCapture CaptureObjectLabelKHR(const State &glState,
+                                         bool isCallValid,
+                                         GLenum identifier,
+                                         GLuint name,
+                                         GLsizei length,
+                                         const GLchar *label);
+angle::CallCapture CaptureObjectPtrLabelKHR(const State &glState,
+                                            bool isCallValid,
+                                            const void *ptr,
+                                            GLsizei length,
+                                            const GLchar *label);
+angle::CallCapture CapturePopDebugGroupKHR(const State &glState, bool isCallValid);
+angle::CallCapture CapturePushDebugGroupKHR(const State &glState,
+                                            bool isCallValid,
+                                            GLenum source,
+                                            GLuint id,
+                                            GLsizei length,
+                                            const GLchar *message);
+
+// GL_KHR_parallel_shader_compile
+angle::CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState,
+                                                      bool isCallValid,
+                                                      GLuint count);
+
+// GL_NV_fence
+angle::CallCapture CaptureDeleteFencesNV(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei n,
+                                         const FenceNVID *fencesPacked);
+angle::CallCapture CaptureFinishFenceNV(const State &glState,
+                                        bool isCallValid,
+                                        FenceNVID fencePacked);
+angle::CallCapture CaptureGenFencesNV(const State &glState,
+                                      bool isCallValid,
+                                      GLsizei n,
+                                      FenceNVID *fencesPacked);
+angle::CallCapture CaptureGetFenceivNV(const State &glState,
+                                       bool isCallValid,
+                                       FenceNVID fencePacked,
+                                       GLenum pname,
+                                       GLint *params);
+angle::CallCapture CaptureIsFenceNV(const State &glState,
+                                    bool isCallValid,
+                                    FenceNVID fencePacked,
+                                    GLboolean returnValue);
+angle::CallCapture CaptureSetFenceNV(const State &glState,
+                                     bool isCallValid,
+                                     FenceNVID fencePacked,
+                                     GLenum condition);
+angle::CallCapture CaptureTestFenceNV(const State &glState,
+                                      bool isCallValid,
+                                      FenceNVID fencePacked,
+                                      GLboolean returnValue);
+
+// GL_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_OES_EGL_image
+angle::CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
+                                                               bool isCallValid,
+                                                               GLenum target,
+                                                               GLeglImageOES image);
+angle::CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureType targetPacked,
+                                                     GLeglImageOES image);
+
+// GL_OES_compressed_ETC1_RGB8_texture
+
+// GL_OES_copy_image
+angle::CallCapture CaptureCopyImageSubDataOES(const State &glState,
+                                              bool isCallValid,
+                                              GLuint srcName,
+                                              GLenum srcTarget,
+                                              GLint srcLevel,
+                                              GLint srcX,
+                                              GLint srcY,
+                                              GLint srcZ,
+                                              GLuint dstName,
+                                              GLenum dstTarget,
+                                              GLint dstLevel,
+                                              GLint dstX,
+                                              GLint dstY,
+                                              GLint dstZ,
+                                              GLsizei srcWidth,
+                                              GLsizei srcHeight,
+                                              GLsizei srcDepth);
+
+// GL_OES_depth32
+
+// GL_OES_draw_buffers_indexed
+angle::CallCapture CaptureBlendEquationSeparateiOES(const State &glState,
+                                                    bool isCallValid,
+                                                    GLuint buf,
+                                                    GLenum modeRGB,
+                                                    GLenum modeAlpha);
+angle::CallCapture CaptureBlendEquationiOES(const State &glState,
+                                            bool isCallValid,
+                                            GLuint buf,
+                                            GLenum mode);
+angle::CallCapture CaptureBlendFuncSeparateiOES(const State &glState,
+                                                bool isCallValid,
+                                                GLuint buf,
+                                                GLenum srcRGB,
+                                                GLenum dstRGB,
+                                                GLenum srcAlpha,
+                                                GLenum dstAlpha);
+angle::CallCapture CaptureBlendFunciOES(const State &glState,
+                                        bool isCallValid,
+                                        GLuint buf,
+                                        GLenum src,
+                                        GLenum dst);
+angle::CallCapture CaptureColorMaskiOES(const State &glState,
+                                        bool isCallValid,
+                                        GLuint index,
+                                        GLboolean r,
+                                        GLboolean g,
+                                        GLboolean b,
+                                        GLboolean a);
+angle::CallCapture CaptureDisableiOES(const State &glState,
+                                      bool isCallValid,
+                                      GLenum target,
+                                      GLuint index);
+angle::CallCapture CaptureEnableiOES(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLuint index);
+angle::CallCapture CaptureIsEnablediOES(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLuint index,
+                                        GLboolean returnValue);
+
+// GL_OES_draw_elements_base_vertex
+angle::CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
+                                                    bool isCallValid,
+                                                    PrimitiveMode modePacked,
+                                                    GLsizei count,
+                                                    DrawElementsType typePacked,
+                                                    const void *indices,
+                                                    GLint basevertex);
+angle::CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
+                                                             bool isCallValid,
+                                                             PrimitiveMode modePacked,
+                                                             GLsizei count,
+                                                             DrawElementsType typePacked,
+                                                             const void *indices,
+                                                             GLsizei instancecount,
+                                                             GLint basevertex);
+angle::CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
+                                                         bool isCallValid,
+                                                         PrimitiveMode modePacked,
+                                                         GLuint start,
+                                                         GLuint end,
+                                                         GLsizei count,
+                                                         DrawElementsType typePacked,
+                                                         const void *indices,
+                                                         GLint basevertex);
+
+// GL_OES_draw_texture
+angle::CallCapture CaptureDrawTexfOES(const State &glState,
+                                      bool isCallValid,
+                                      GLfloat x,
+                                      GLfloat y,
+                                      GLfloat z,
+                                      GLfloat width,
+                                      GLfloat height);
+angle::CallCapture CaptureDrawTexfvOES(const State &glState,
+                                       bool isCallValid,
+                                       const GLfloat *coords);
+angle::CallCapture CaptureDrawTexiOES(const State &glState,
+                                      bool isCallValid,
+                                      GLint x,
+                                      GLint y,
+                                      GLint z,
+                                      GLint width,
+                                      GLint height);
+angle::CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords);
+angle::CallCapture CaptureDrawTexsOES(const State &glState,
+                                      bool isCallValid,
+                                      GLshort x,
+                                      GLshort y,
+                                      GLshort z,
+                                      GLshort width,
+                                      GLshort height);
+angle::CallCapture CaptureDrawTexsvOES(const State &glState,
+                                       bool isCallValid,
+                                       const GLshort *coords);
+angle::CallCapture CaptureDrawTexxOES(const State &glState,
+                                      bool isCallValid,
+                                      GLfixed x,
+                                      GLfixed y,
+                                      GLfixed z,
+                                      GLfixed width,
+                                      GLfixed height);
+angle::CallCapture CaptureDrawTexxvOES(const State &glState,
+                                       bool isCallValid,
+                                       const GLfixed *coords);
+
+// GL_OES_framebuffer_object
+angle::CallCapture CaptureBindFramebufferOES(const State &glState,
+                                             bool isCallValid,
+                                             GLenum target,
+                                             FramebufferID framebufferPacked);
+angle::CallCapture CaptureBindRenderbufferOES(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              RenderbufferID renderbufferPacked);
+angle::CallCapture CaptureCheckFramebufferStatusOES(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum target,
+                                                    GLenum returnValue);
+angle::CallCapture CaptureDeleteFramebuffersOES(const State &glState,
+                                                bool isCallValid,
+                                                GLsizei n,
+                                                const FramebufferID *framebuffersPacked);
+angle::CallCapture CaptureDeleteRenderbuffersOES(const State &glState,
+                                                 bool isCallValid,
+                                                 GLsizei n,
+                                                 const RenderbufferID *renderbuffersPacked);
+angle::CallCapture CaptureFramebufferRenderbufferOES(const State &glState,
+                                                     bool isCallValid,
+                                                     GLenum target,
+                                                     GLenum attachment,
+                                                     GLenum renderbuffertarget,
+                                                     RenderbufferID renderbufferPacked);
+angle::CallCapture CaptureFramebufferTexture2DOES(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum target,
+                                                  GLenum attachment,
+                                                  TextureTarget textargetPacked,
+                                                  TextureID texturePacked,
+                                                  GLint level);
+angle::CallCapture CaptureGenFramebuffersOES(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             FramebufferID *framebuffersPacked);
+angle::CallCapture CaptureGenRenderbuffersOES(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              RenderbufferID *renderbuffersPacked);
+angle::CallCapture CaptureGenerateMipmapOES(const State &glState,
+                                            bool isCallValid,
+                                            TextureType targetPacked);
+angle::CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState,
+                                                                 bool isCallValid,
+                                                                 GLenum target,
+                                                                 GLenum attachment,
+                                                                 GLenum pname,
+                                                                 GLint *params);
+angle::CallCapture CaptureGetRenderbufferParameterivOES(const State &glState,
+                                                        bool isCallValid,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLint *params);
+angle::CallCapture CaptureIsFramebufferOES(const State &glState,
+                                           bool isCallValid,
+                                           FramebufferID framebufferPacked,
+                                           GLboolean returnValue);
+angle::CallCapture CaptureIsRenderbufferOES(const State &glState,
+                                            bool isCallValid,
+                                            RenderbufferID renderbufferPacked,
+                                            GLboolean returnValue);
+angle::CallCapture CaptureRenderbufferStorageOES(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum target,
+                                                 GLenum internalformat,
+                                                 GLsizei width,
+                                                 GLsizei height);
+
+// GL_OES_get_program_binary
+angle::CallCapture CaptureGetProgramBinaryOES(const State &glState,
+                                              bool isCallValid,
+                                              ShaderProgramID programPacked,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLenum *binaryFormat,
+                                              void *binary);
+angle::CallCapture CaptureProgramBinaryOES(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           GLenum binaryFormat,
+                                           const void *binary,
+                                           GLint length);
+
+// GL_OES_mapbuffer
+angle::CallCapture CaptureGetBufferPointervOES(const State &glState,
+                                               bool isCallValid,
+                                               BufferBinding targetPacked,
+                                               GLenum pname,
+                                               void **params);
+angle::CallCapture CaptureMapBufferOES(const State &glState,
+                                       bool isCallValid,
+                                       BufferBinding targetPacked,
+                                       GLenum access,
+                                       void *returnValue);
+angle::CallCapture CaptureUnmapBufferOES(const State &glState,
+                                         bool isCallValid,
+                                         BufferBinding targetPacked,
+                                         GLboolean returnValue);
+
+// GL_OES_matrix_palette
+angle::CallCapture CaptureCurrentPaletteMatrixOES(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint matrixpaletteindex);
+angle::CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid);
+angle::CallCapture CaptureMatrixIndexPointerOES(const State &glState,
+                                                bool isCallValid,
+                                                GLint size,
+                                                GLenum type,
+                                                GLsizei stride,
+                                                const void *pointer);
+angle::CallCapture CaptureWeightPointerOES(const State &glState,
+                                           bool isCallValid,
+                                           GLint size,
+                                           GLenum type,
+                                           GLsizei stride,
+                                           const void *pointer);
+
+// GL_OES_point_size_array
+angle::CallCapture CapturePointSizePointerOES(const State &glState,
+                                              bool isCallValid,
+                                              VertexAttribType typePacked,
+                                              GLsizei stride,
+                                              const void *pointer);
+
+// GL_OES_query_matrix
+angle::CallCapture CaptureQueryMatrixxOES(const State &glState,
+                                          bool isCallValid,
+                                          GLfixed *mantissa,
+                                          GLint *exponent,
+                                          GLbitfield returnValue);
+
+// GL_OES_sample_shading
+angle::CallCapture CaptureMinSampleShadingOES(const State &glState,
+                                              bool isCallValid,
+                                              GLfloat value);
+
+// GL_OES_shader_io_blocks
+
+// GL_OES_texture_3D
+angle::CallCapture CaptureCompressedTexImage3DOES(const State &glState,
+                                                  bool isCallValid,
+                                                  TextureTarget targetPacked,
+                                                  GLint level,
+                                                  GLenum internalformat,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLsizei depth,
+                                                  GLint border,
+                                                  GLsizei imageSize,
+                                                  const void *data);
+angle::CallCapture CaptureCompressedTexSubImage3DOES(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureTarget targetPacked,
+                                                     GLint level,
+                                                     GLint xoffset,
+                                                     GLint yoffset,
+                                                     GLint zoffset,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLsizei depth,
+                                                     GLenum format,
+                                                     GLsizei imageSize,
+                                                     const void *data);
+angle::CallCapture CaptureCopyTexSubImage3DOES(const State &glState,
+                                               bool isCallValid,
+                                               TextureTarget targetPacked,
+                                               GLint level,
+                                               GLint xoffset,
+                                               GLint yoffset,
+                                               GLint zoffset,
+                                               GLint x,
+                                               GLint y,
+                                               GLsizei width,
+                                               GLsizei height);
+angle::CallCapture CaptureFramebufferTexture3DOES(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum target,
+                                                  GLenum attachment,
+                                                  TextureTarget textargetPacked,
+                                                  TextureID texturePacked,
+                                                  GLint level,
+                                                  GLint zoffset);
+angle::CallCapture CaptureTexImage3DOES(const State &glState,
+                                        bool isCallValid,
+                                        TextureTarget targetPacked,
+                                        GLint level,
+                                        GLenum internalformat,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLsizei depth,
+                                        GLint border,
+                                        GLenum format,
+                                        GLenum type,
+                                        const void *pixels);
+angle::CallCapture CaptureTexSubImage3DOES(const State &glState,
+                                           bool isCallValid,
+                                           TextureTarget targetPacked,
+                                           GLint level,
+                                           GLint xoffset,
+                                           GLint yoffset,
+                                           GLint zoffset,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth,
+                                           GLenum format,
+                                           GLenum type,
+                                           const void *pixels);
+
+// GL_OES_texture_border_clamp
+angle::CallCapture CaptureGetSamplerParameterIivOES(const State &glState,
+                                                    bool isCallValid,
+                                                    SamplerID samplerPacked,
+                                                    GLenum pname,
+                                                    GLint *params);
+angle::CallCapture CaptureGetSamplerParameterIuivOES(const State &glState,
+                                                     bool isCallValid,
+                                                     SamplerID samplerPacked,
+                                                     GLenum pname,
+                                                     GLuint *params);
+angle::CallCapture CaptureGetTexParameterIivOES(const State &glState,
+                                                bool isCallValid,
+                                                TextureType targetPacked,
+                                                GLenum pname,
+                                                GLint *params);
+angle::CallCapture CaptureGetTexParameterIuivOES(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureType targetPacked,
+                                                 GLenum pname,
+                                                 GLuint *params);
+angle::CallCapture CaptureSamplerParameterIivOES(const State &glState,
+                                                 bool isCallValid,
+                                                 SamplerID samplerPacked,
+                                                 GLenum pname,
+                                                 const GLint *param);
+angle::CallCapture CaptureSamplerParameterIuivOES(const State &glState,
+                                                  bool isCallValid,
+                                                  SamplerID samplerPacked,
+                                                  GLenum pname,
+                                                  const GLuint *param);
+angle::CallCapture CaptureTexParameterIivOES(const State &glState,
+                                             bool isCallValid,
+                                             TextureType targetPacked,
+                                             GLenum pname,
+                                             const GLint *params);
+angle::CallCapture CaptureTexParameterIuivOES(const State &glState,
+                                              bool isCallValid,
+                                              TextureType targetPacked,
+                                              GLenum pname,
+                                              const GLuint *params);
+
+// GL_OES_texture_buffer
+angle::CallCapture CaptureTexBufferOES(const State &glState,
+                                       bool isCallValid,
+                                       TextureType targetPacked,
+                                       GLenum internalformat,
+                                       BufferID bufferPacked);
+angle::CallCapture CaptureTexBufferRangeOES(const State &glState,
+                                            bool isCallValid,
+                                            TextureType targetPacked,
+                                            GLenum internalformat,
+                                            BufferID bufferPacked,
+                                            GLintptr offset,
+                                            GLsizeiptr size);
+
+// GL_OES_texture_cube_map
+angle::CallCapture CaptureGetTexGenfvOES(const State &glState,
+                                         bool isCallValid,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         GLfloat *params);
+angle::CallCapture CaptureGetTexGenivOES(const State &glState,
+                                         bool isCallValid,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         GLint *params);
+angle::CallCapture CaptureGetTexGenxvOES(const State &glState,
+                                         bool isCallValid,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         GLfixed *params);
+angle::CallCapture CaptureTexGenfOES(const State &glState,
+                                     bool isCallValid,
+                                     GLenum coord,
+                                     GLenum pname,
+                                     GLfloat param);
+angle::CallCapture CaptureTexGenfvOES(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      const GLfloat *params);
+angle::CallCapture CaptureTexGeniOES(const State &glState,
+                                     bool isCallValid,
+                                     GLenum coord,
+                                     GLenum pname,
+                                     GLint param);
+angle::CallCapture CaptureTexGenivOES(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      const GLint *params);
+angle::CallCapture CaptureTexGenxOES(const State &glState,
+                                     bool isCallValid,
+                                     GLenum coord,
+                                     GLenum pname,
+                                     GLfixed param);
+angle::CallCapture CaptureTexGenxvOES(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      const GLfixed *params);
+
+// GL_OES_texture_cube_map_array
+
+// GL_OES_texture_half_float
+
+// GL_OES_texture_stencil8
+
+// GL_OES_texture_storage_multisample_2d_array
+angle::CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureType targetPacked,
+                                                     GLsizei samples,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLsizei depth,
+                                                     GLboolean fixedsamplelocations);
+
+// GL_OES_vertex_array_object
+angle::CallCapture CaptureBindVertexArrayOES(const State &glState,
+                                             bool isCallValid,
+                                             VertexArrayID arrayPacked);
+angle::CallCapture CaptureDeleteVertexArraysOES(const State &glState,
+                                                bool isCallValid,
+                                                GLsizei n,
+                                                const VertexArrayID *arraysPacked);
+angle::CallCapture CaptureGenVertexArraysOES(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             VertexArrayID *arraysPacked);
+angle::CallCapture CaptureIsVertexArrayOES(const State &glState,
+                                           bool isCallValid,
+                                           VertexArrayID arrayPacked,
+                                           GLboolean returnValue);
+
+// GL_OVR_multiview
+angle::CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
+                                                         bool isCallValid,
+                                                         GLenum target,
+                                                         GLenum attachment,
+                                                         TextureID texturePacked,
+                                                         GLint level,
+                                                         GLint baseViewIndex,
+                                                         GLsizei numViews);
+
+// GL_OVR_multiview2
+
+// Parameter Captures
+
+void CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    GLsizei count,
+    DrawElementsType typePacked,
+    const GLvoid *indices,
+    GLsizei instanceCounts,
+    GLint baseVertex,
+    GLuint baseInstance,
+    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(const State &glState,
+                                                             bool isCallValid,
+                                                             PrimitiveMode modePacked,
+                                                             const GLint *firsts,
+                                                             const GLsizei *counts,
+                                                             const GLsizei *instanceCounts,
+                                                             const GLuint *baseInstances,
+                                                             GLsizei drawcount,
+                                                             angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_counts(const State &glState,
+                                                             bool isCallValid,
+                                                             PrimitiveMode modePacked,
+                                                             const GLint *firsts,
+                                                             const GLsizei *counts,
+                                                             const GLsizei *instanceCounts,
+                                                             const GLuint *baseInstances,
+                                                             GLsizei drawcount,
+                                                             angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_instanceCounts(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLint *firsts,
+    const GLsizei *counts,
+    const GLsizei *instanceCounts,
+    const GLuint *baseInstances,
+    GLsizei drawcount,
+    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_baseInstances(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLint *firsts,
+    const GLsizei *counts,
+    const GLsizei *instanceCounts,
+    const GLuint *baseInstances,
+    GLsizei drawcount,
+    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_counts(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLsizei *counts,
+    DrawElementsType typePacked,
+    const GLvoid *const *indices,
+    const GLsizei *instanceCounts,
+    const GLint *baseVertices,
+    const GLuint *baseInstances,
+    GLsizei drawcount,
+    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLsizei *counts,
+    DrawElementsType typePacked,
+    const GLvoid *const *indices,
+    const GLsizei *instanceCounts,
+    const GLint *baseVertices,
+    const GLuint *baseInstances,
+    GLsizei drawcount,
+    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLsizei *counts,
+    DrawElementsType typePacked,
+    const GLvoid *const *indices,
+    const GLsizei *instanceCounts,
+    const GLint *baseVertices,
+    const GLuint *baseInstances,
+    GLsizei drawcount,
+    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLsizei *counts,
+    DrawElementsType typePacked,
+    const GLvoid *const *indices,
+    const GLsizei *instanceCounts,
+    const GLint *baseVertices,
+    const GLuint *baseInstances,
+    GLsizei drawcount,
+    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLsizei *counts,
+    DrawElementsType typePacked,
+    const GLvoid *const *indices,
+    const GLsizei *instanceCounts,
+    const GLint *baseVertices,
+    const GLuint *baseInstances,
+    GLsizei drawcount,
+    angle::ParamCapture *paramCapture);
+void CaptureGetTexImageANGLE_pixels(const State &glState,
+                                    bool isCallValid,
+                                    TextureTarget targetPacked,
+                                    GLint level,
+                                    GLenum format,
+                                    GLenum type,
+                                    void *pixels,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetRenderbufferImageANGLE_pixels(const State &glState,
+                                             bool isCallValid,
+                                             GLenum target,
+                                             GLenum format,
+                                             GLenum type,
+                                             void *pixels,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetTexLevelParameterivANGLE_params(const State &glState,
+                                               bool isCallValid,
+                                               TextureTarget targetPacked,
+                                               GLint level,
+                                               GLenum pname,
+                                               GLint *params,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetTexLevelParameterfvANGLE_params(const State &glState,
+                                               bool isCallValid,
+                                               TextureTarget targetPacked,
+                                               GLint level,
+                                               GLenum pname,
+                                               GLfloat *params,
+                                               angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedANGLE_indices(const State &glState,
+                                               bool isCallValid,
+                                               PrimitiveMode modePacked,
+                                               GLsizei count,
+                                               DrawElementsType typePacked,
+                                               const void *indices,
+                                               GLsizei primcount,
+                                               angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysANGLE_firsts(const State &glState,
+                                        bool isCallValid,
+                                        PrimitiveMode modePacked,
+                                        const GLint *firsts,
+                                        const GLsizei *counts,
+                                        GLsizei drawcount,
+                                        angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysANGLE_counts(const State &glState,
+                                        bool isCallValid,
+                                        PrimitiveMode modePacked,
+                                        const GLint *firsts,
+                                        const GLsizei *counts,
+                                        GLsizei drawcount,
+                                        angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysInstancedANGLE_firsts(const State &glState,
+                                                 bool isCallValid,
+                                                 PrimitiveMode modePacked,
+                                                 const GLint *firsts,
+                                                 const GLsizei *counts,
+                                                 const GLsizei *instanceCounts,
+                                                 GLsizei drawcount,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysInstancedANGLE_counts(const State &glState,
+                                                 bool isCallValid,
+                                                 PrimitiveMode modePacked,
+                                                 const GLint *firsts,
+                                                 const GLsizei *counts,
+                                                 const GLsizei *instanceCounts,
+                                                 GLsizei drawcount,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysInstancedANGLE_instanceCounts(const State &glState,
+                                                         bool isCallValid,
+                                                         PrimitiveMode modePacked,
+                                                         const GLint *firsts,
+                                                         const GLsizei *counts,
+                                                         const GLsizei *instanceCounts,
+                                                         GLsizei drawcount,
+                                                         angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsANGLE_counts(const State &glState,
+                                          bool isCallValid,
+                                          PrimitiveMode modePacked,
+                                          const GLsizei *counts,
+                                          DrawElementsType typePacked,
+                                          const GLvoid *const *indices,
+                                          GLsizei drawcount,
+                                          angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsANGLE_indices(const State &glState,
+                                           bool isCallValid,
+                                           PrimitiveMode modePacked,
+                                           const GLsizei *counts,
+                                           DrawElementsType typePacked,
+                                           const GLvoid *const *indices,
+                                           GLsizei drawcount,
+                                           angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsInstancedANGLE_counts(const State &glState,
+                                                   bool isCallValid,
+                                                   PrimitiveMode modePacked,
+                                                   const GLsizei *counts,
+                                                   DrawElementsType typePacked,
+                                                   const GLvoid *const *indices,
+                                                   const GLsizei *instanceCounts,
+                                                   GLsizei drawcount,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsInstancedANGLE_indices(const State &glState,
+                                                    bool isCallValid,
+                                                    PrimitiveMode modePacked,
+                                                    const GLsizei *counts,
+                                                    DrawElementsType typePacked,
+                                                    const GLvoid *const *indices,
+                                                    const GLsizei *instanceCounts,
+                                                    GLsizei drawcount,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsInstancedANGLE_instanceCounts(const State &glState,
+                                                           bool isCallValid,
+                                                           PrimitiveMode modePacked,
+                                                           const GLsizei *counts,
+                                                           DrawElementsType typePacked,
+                                                           const GLvoid *const *indices,
+                                                           const GLsizei *instanceCounts,
+                                                           GLsizei drawcount,
+                                                           angle::ParamCapture *paramCapture);
+void CaptureRequestExtensionANGLE_name(const State &glState,
+                                       bool isCallValid,
+                                       const GLchar *name,
+                                       angle::ParamCapture *paramCapture);
+void CaptureDisableExtensionANGLE_name(const State &glState,
+                                       bool isCallValid,
+                                       const GLchar *name,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetBooleanvRobustANGLE_length(const State &glState,
+                                          bool isCallValid,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLboolean *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetBooleanvRobustANGLE_params(const State &glState,
+                                          bool isCallValid,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLboolean *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetBufferParameterivRobustANGLE_length(const State &glState,
+                                                   bool isCallValid,
+                                                   BufferBinding targetPacked,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *params,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureGetBufferParameterivRobustANGLE_params(const State &glState,
+                                                   bool isCallValid,
+                                                   BufferBinding targetPacked,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *params,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureGetFloatvRobustANGLE_length(const State &glState,
+                                        bool isCallValid,
+                                        GLenum pname,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLfloat *params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetFloatvRobustANGLE_params(const State &glState,
+                                        bool isCallValid,
+                                        GLenum pname,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLfloat *params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(
+    const State &glState,
+    bool isCallValid,
+    GLenum target,
+    GLenum attachment,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei *length,
+    GLint *params,
+    angle::ParamCapture *paramCapture);
+void CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(
+    const State &glState,
+    bool isCallValid,
+    GLenum target,
+    GLenum attachment,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei *length,
+    GLint *params,
+    angle::ParamCapture *paramCapture);
+void CaptureGetIntegervRobustANGLE_length(const State &glState,
+                                          bool isCallValid,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint *data,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetIntegervRobustANGLE_data(const State &glState,
+                                        bool isCallValid,
+                                        GLenum pname,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLint *data,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetProgramivRobustANGLE_length(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           GLenum pname,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetProgramivRobustANGLE_params(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           GLenum pname,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetRenderbufferParameterivRobustANGLE_length(const State &glState,
+                                                         bool isCallValid,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLint *params,
+                                                         angle::ParamCapture *paramCapture);
+void CaptureGetRenderbufferParameterivRobustANGLE_params(const State &glState,
+                                                         bool isCallValid,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLint *params,
+                                                         angle::ParamCapture *paramCapture);
+void CaptureGetShaderivRobustANGLE_length(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID shaderPacked,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetShaderivRobustANGLE_params(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID shaderPacked,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterfvRobustANGLE_length(const State &glState,
+                                                bool isCallValid,
+                                                TextureType targetPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLfloat *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterfvRobustANGLE_params(const State &glState,
+                                                bool isCallValid,
+                                                TextureType targetPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLfloat *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterivRobustANGLE_length(const State &glState,
+                                                bool isCallValid,
+                                                TextureType targetPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterivRobustANGLE_params(const State &glState,
+                                                bool isCallValid,
+                                                TextureType targetPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetUniformfvRobustANGLE_length(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLfloat *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetUniformfvRobustANGLE_params(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLfloat *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetUniformivRobustANGLE_length(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetUniformivRobustANGLE_params(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribfvRobustANGLE_length(const State &glState,
+                                                bool isCallValid,
+                                                GLuint index,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLfloat *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribfvRobustANGLE_params(const State &glState,
+                                                bool isCallValid,
+                                                GLuint index,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLfloat *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribivRobustANGLE_length(const State &glState,
+                                                bool isCallValid,
+                                                GLuint index,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribivRobustANGLE_params(const State &glState,
+                                                bool isCallValid,
+                                                GLuint index,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribPointervRobustANGLE_length(const State &glState,
+                                                      bool isCallValid,
+                                                      GLuint index,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      void **pointer,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribPointervRobustANGLE_pointer(const State &glState,
+                                                       bool isCallValid,
+                                                       GLuint index,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       void **pointer,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureReadPixelsRobustANGLE_length(const State &glState,
+                                         bool isCallValid,
+                                         GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLsizei *columns,
+                                         GLsizei *rows,
+                                         void *pixels,
+                                         angle::ParamCapture *paramCapture);
+void CaptureReadPixelsRobustANGLE_columns(const State &glState,
+                                          bool isCallValid,
+                                          GLint x,
+                                          GLint y,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLsizei *columns,
+                                          GLsizei *rows,
+                                          void *pixels,
+                                          angle::ParamCapture *paramCapture);
+void CaptureReadPixelsRobustANGLE_rows(const State &glState,
+                                       bool isCallValid,
+                                       GLint x,
+                                       GLint y,
+                                       GLsizei width,
+                                       GLsizei height,
+                                       GLenum format,
+                                       GLenum type,
+                                       GLsizei bufSize,
+                                       GLsizei *length,
+                                       GLsizei *columns,
+                                       GLsizei *rows,
+                                       void *pixels,
+                                       angle::ParamCapture *paramCapture);
+void CaptureReadPixelsRobustANGLE_pixels(const State &glState,
+                                         bool isCallValid,
+                                         GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLsizei *columns,
+                                         GLsizei *rows,
+                                         void *pixels,
+                                         angle::ParamCapture *paramCapture);
+void CaptureTexImage2DRobustANGLE_pixels(const State &glState,
+                                         bool isCallValid,
+                                         TextureTarget targetPacked,
+                                         GLint level,
+                                         GLint internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         const void *pixels,
+                                         angle::ParamCapture *paramCapture);
+void CaptureTexParameterfvRobustANGLE_params(const State &glState,
+                                             bool isCallValid,
+                                             TextureType targetPacked,
+                                             GLenum pname,
+                                             GLsizei bufSize,
+                                             const GLfloat *params,
+                                             angle::ParamCapture *paramCapture);
+void CaptureTexParameterivRobustANGLE_params(const State &glState,
+                                             bool isCallValid,
+                                             TextureType targetPacked,
+                                             GLenum pname,
+                                             GLsizei bufSize,
+                                             const GLint *params,
+                                             angle::ParamCapture *paramCapture);
+void CaptureTexSubImage2DRobustANGLE_pixels(const State &glState,
+                                            bool isCallValid,
+                                            TextureTarget targetPacked,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            GLsizei bufSize,
+                                            const void *pixels,
+                                            angle::ParamCapture *paramCapture);
+void CaptureTexImage3DRobustANGLE_pixels(const State &glState,
+                                         bool isCallValid,
+                                         TextureTarget targetPacked,
+                                         GLint level,
+                                         GLint internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         const void *pixels,
+                                         angle::ParamCapture *paramCapture);
+void CaptureTexSubImage3DRobustANGLE_pixels(const State &glState,
+                                            bool isCallValid,
+                                            TextureTarget targetPacked,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLenum type,
+                                            GLsizei bufSize,
+                                            const void *pixels,
+                                            angle::ParamCapture *paramCapture);
+void CaptureCompressedTexImage2DRobustANGLE_data(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureTarget targetPacked,
+                                                 GLint level,
+                                                 GLenum internalformat,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLint border,
+                                                 GLsizei imageSize,
+                                                 GLsizei dataSize,
+                                                 const GLvoid *data,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureCompressedTexSubImage2DRobustANGLE_data(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureTarget targetPacked,
+                                                    GLint level,
+                                                    GLsizei xoffset,
+                                                    GLsizei yoffset,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLenum format,
+                                                    GLsizei imageSize,
+                                                    GLsizei dataSize,
+                                                    const GLvoid *data,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureCompressedTexImage3DRobustANGLE_data(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureTarget targetPacked,
+                                                 GLint level,
+                                                 GLenum internalformat,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLsizei depth,
+                                                 GLint border,
+                                                 GLsizei imageSize,
+                                                 GLsizei dataSize,
+                                                 const GLvoid *data,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureCompressedTexSubImage3DRobustANGLE_data(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureTarget targetPacked,
+                                                    GLint level,
+                                                    GLint xoffset,
+                                                    GLint yoffset,
+                                                    GLint zoffset,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLsizei depth,
+                                                    GLenum format,
+                                                    GLsizei imageSize,
+                                                    GLsizei dataSize,
+                                                    const GLvoid *data,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureGetQueryivRobustANGLE_length(const State &glState,
+                                         bool isCallValid,
+                                         QueryType targetPacked,
+                                         GLenum pname,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLint *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetQueryivRobustANGLE_params(const State &glState,
+                                         bool isCallValid,
+                                         QueryType targetPacked,
+                                         GLenum pname,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLint *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectuivRobustANGLE_length(const State &glState,
+                                                bool isCallValid,
+                                                QueryID idPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLuint *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectuivRobustANGLE_params(const State &glState,
+                                                bool isCallValid,
+                                                QueryID idPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLuint *params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetBufferPointervRobustANGLE_length(const State &glState,
+                                                bool isCallValid,
+                                                BufferBinding targetPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                void **params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetBufferPointervRobustANGLE_params(const State &glState,
+                                                bool isCallValid,
+                                                BufferBinding targetPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                void **params,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetIntegeri_vRobustANGLE_length(const State &glState,
+                                            bool isCallValid,
+                                            GLenum target,
+                                            GLuint index,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint *data,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetIntegeri_vRobustANGLE_data(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLuint index,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint *data,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetInternalformativRobustANGLE_length(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum target,
+                                                  GLenum internalformat,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLint *params,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetInternalformativRobustANGLE_params(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum target,
+                                                  GLenum internalformat,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLint *params,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribIivRobustANGLE_length(const State &glState,
+                                                 bool isCallValid,
+                                                 GLuint index,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribIivRobustANGLE_params(const State &glState,
+                                                 bool isCallValid,
+                                                 GLuint index,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribIuivRobustANGLE_length(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint index,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint *params,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribIuivRobustANGLE_params(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint index,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint *params,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetUniformuivRobustANGLE_length(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLuint *params,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetUniformuivRobustANGLE_params(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLuint *params,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniformBlockivRobustANGLE_length(const State &glState,
+                                                      bool isCallValid,
+                                                      ShaderProgramID programPacked,
+                                                      UniformBlockIndex uniformBlockIndexPacked,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniformBlockivRobustANGLE_params(const State &glState,
+                                                      bool isCallValid,
+                                                      ShaderProgramID programPacked,
+                                                      UniformBlockIndex uniformBlockIndexPacked,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureGetInteger64vRobustANGLE_length(const State &glState,
+                                            bool isCallValid,
+                                            GLenum pname,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint64 *data,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetInteger64vRobustANGLE_data(const State &glState,
+                                          bool isCallValid,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint64 *data,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetInteger64i_vRobustANGLE_length(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              GLuint index,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLint64 *data,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetInteger64i_vRobustANGLE_data(const State &glState,
+                                            bool isCallValid,
+                                            GLenum target,
+                                            GLuint index,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint64 *data,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetBufferParameteri64vRobustANGLE_length(const State &glState,
+                                                     bool isCallValid,
+                                                     BufferBinding targetPacked,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint64 *params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetBufferParameteri64vRobustANGLE_params(const State &glState,
+                                                     bool isCallValid,
+                                                     BufferBinding targetPacked,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint64 *params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterivRobustANGLE_param(const State &glState,
+                                                bool isCallValid,
+                                                SamplerID samplerPacked,
+                                                GLuint pname,
+                                                GLsizei bufSize,
+                                                const GLint *param,
+                                                angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterfvRobustANGLE_param(const State &glState,
+                                                bool isCallValid,
+                                                SamplerID samplerPacked,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                const GLfloat *param,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterivRobustANGLE_length(const State &glState,
+                                                    bool isCallValid,
+                                                    SamplerID samplerPacked,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterivRobustANGLE_params(const State &glState,
+                                                    bool isCallValid,
+                                                    SamplerID samplerPacked,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterfvRobustANGLE_length(const State &glState,
+                                                    bool isCallValid,
+                                                    SamplerID samplerPacked,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLfloat *params,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterfvRobustANGLE_params(const State &glState,
+                                                    bool isCallValid,
+                                                    SamplerID samplerPacked,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLfloat *params,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureGetFramebufferParameterivRobustANGLE_length(const State &glState,
+                                                        bool isCallValid,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint *params,
+                                                        angle::ParamCapture *paramCapture);
+void CaptureGetFramebufferParameterivRobustANGLE_params(const State &glState,
+                                                        bool isCallValid,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint *params,
+                                                        angle::ParamCapture *paramCapture);
+void CaptureGetProgramInterfaceivRobustANGLE_length(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    GLenum programInterface,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureGetProgramInterfaceivRobustANGLE_params(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    GLenum programInterface,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureGetBooleani_vRobustANGLE_length(const State &glState,
+                                            bool isCallValid,
+                                            GLenum target,
+                                            GLuint index,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLboolean *data,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetBooleani_vRobustANGLE_data(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLuint index,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLboolean *data,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetMultisamplefvRobustANGLE_length(const State &glState,
+                                               bool isCallValid,
+                                               GLenum pname,
+                                               GLuint index,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLfloat *val,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetMultisamplefvRobustANGLE_val(const State &glState,
+                                            bool isCallValid,
+                                            GLenum pname,
+                                            GLuint index,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLfloat *val,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetTexLevelParameterivRobustANGLE_length(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureTarget targetPacked,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetTexLevelParameterivRobustANGLE_params(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureTarget targetPacked,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetTexLevelParameterfvRobustANGLE_length(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureTarget targetPacked,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLfloat *params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetTexLevelParameterfvRobustANGLE_params(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureTarget targetPacked,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLfloat *params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetPointervRobustANGLERobustANGLE_length(const State &glState,
+                                                     bool isCallValid,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     void **params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetPointervRobustANGLERobustANGLE_params(const State &glState,
+                                                     bool isCallValid,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     void **params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureReadnPixelsRobustANGLE_length(const State &glState,
+                                          bool isCallValid,
+                                          GLint x,
+                                          GLint y,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLsizei *columns,
+                                          GLsizei *rows,
+                                          void *data,
+                                          angle::ParamCapture *paramCapture);
+void CaptureReadnPixelsRobustANGLE_columns(const State &glState,
+                                           bool isCallValid,
+                                           GLint x,
+                                           GLint y,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLenum format,
+                                           GLenum type,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLsizei *columns,
+                                           GLsizei *rows,
+                                           void *data,
+                                           angle::ParamCapture *paramCapture);
+void CaptureReadnPixelsRobustANGLE_rows(const State &glState,
+                                        bool isCallValid,
+                                        GLint x,
+                                        GLint y,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLenum format,
+                                        GLenum type,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLsizei *columns,
+                                        GLsizei *rows,
+                                        void *data,
+                                        angle::ParamCapture *paramCapture);
+void CaptureReadnPixelsRobustANGLE_data(const State &glState,
+                                        bool isCallValid,
+                                        GLint x,
+                                        GLint y,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLenum format,
+                                        GLenum type,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLsizei *columns,
+                                        GLsizei *rows,
+                                        void *data,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetnUniformfvRobustANGLE_length(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLfloat *params,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetnUniformfvRobustANGLE_params(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLfloat *params,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetnUniformivRobustANGLE_length(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint *params,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetnUniformivRobustANGLE_params(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint *params,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetnUniformuivRobustANGLE_length(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLuint *params,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetnUniformuivRobustANGLE_params(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLuint *params,
+                                             angle::ParamCapture *paramCapture);
+void CaptureTexParameterIivRobustANGLE_params(const State &glState,
+                                              bool isCallValid,
+                                              TextureType targetPacked,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              const GLint *params,
+                                              angle::ParamCapture *paramCapture);
+void CaptureTexParameterIuivRobustANGLE_params(const State &glState,
+                                               bool isCallValid,
+                                               TextureType targetPacked,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               const GLuint *params,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIivRobustANGLE_length(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureType targetPacked,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIivRobustANGLE_params(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureType targetPacked,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIuivRobustANGLE_length(const State &glState,
+                                                  bool isCallValid,
+                                                  TextureType targetPacked,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint *params,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIuivRobustANGLE_params(const State &glState,
+                                                  bool isCallValid,
+                                                  TextureType targetPacked,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint *params,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterIivRobustANGLE_param(const State &glState,
+                                                 bool isCallValid,
+                                                 SamplerID samplerPacked,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 const GLint *param,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterIuivRobustANGLE_param(const State &glState,
+                                                  bool isCallValid,
+                                                  SamplerID samplerPacked,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  const GLuint *param,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIivRobustANGLE_length(const State &glState,
+                                                     bool isCallValid,
+                                                     SamplerID samplerPacked,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIivRobustANGLE_params(const State &glState,
+                                                     bool isCallValid,
+                                                     SamplerID samplerPacked,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIuivRobustANGLE_length(const State &glState,
+                                                      bool isCallValid,
+                                                      SamplerID samplerPacked,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLuint *params,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIuivRobustANGLE_params(const State &glState,
+                                                      bool isCallValid,
+                                                      SamplerID samplerPacked,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLuint *params,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectivRobustANGLE_length(const State &glState,
+                                               bool isCallValid,
+                                               QueryID idPacked,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *params,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectivRobustANGLE_params(const State &glState,
+                                               bool isCallValid,
+                                               QueryID idPacked,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *params,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjecti64vRobustANGLE_length(const State &glState,
+                                                 bool isCallValid,
+                                                 QueryID idPacked,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint64 *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjecti64vRobustANGLE_params(const State &glState,
+                                                 bool isCallValid,
+                                                 QueryID idPacked,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint64 *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectui64vRobustANGLE_length(const State &glState,
+                                                  bool isCallValid,
+                                                  QueryID idPacked,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint64 *params,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectui64vRobustANGLE_params(const State &glState,
+                                                  bool isCallValid,
+                                                  QueryID idPacked,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint64 *params,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetMultisamplefvANGLE_val(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      GLuint index,
+                                      GLfloat *val,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGetTranslatedShaderSourceANGLE_length(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID shaderPacked,
+                                                  GLsizei bufsize,
+                                                  GLsizei *length,
+                                                  GLchar *source,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetTranslatedShaderSourceANGLE_source(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID shaderPacked,
+                                                  GLsizei bufsize,
+                                                  GLsizei *length,
+                                                  GLchar *source,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureBindUniformLocationCHROMIUM_name(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             const GLchar *name,
+                                             angle::ParamCapture *paramCapture);
+void CaptureBindFragDataLocationEXT_name(const State &glState,
+                                         bool isCallValid,
+                                         ShaderProgramID programPacked,
+                                         GLuint color,
+                                         const GLchar *name,
+                                         angle::ParamCapture *paramCapture);
+void CaptureBindFragDataLocationIndexedEXT_name(const State &glState,
+                                                bool isCallValid,
+                                                ShaderProgramID programPacked,
+                                                GLuint colorNumber,
+                                                GLuint index,
+                                                const GLchar *name,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetFragDataIndexEXT_name(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     const GLchar *name,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceLocationIndexEXT_name(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    GLenum programInterface,
+                                                    const GLchar *name,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureBufferStorageEXT_data(const State &glState,
+                                  bool isCallValid,
+                                  BufferBinding targetPacked,
+                                  GLsizeiptr size,
+                                  const void *data,
+                                  GLbitfield flags,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetObjectLabelEXT_length(const State &glState,
+                                     bool isCallValid,
+                                     GLenum type,
+                                     GLuint object,
+                                     GLsizei bufSize,
+                                     GLsizei *length,
+                                     GLchar *label,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetObjectLabelEXT_label(const State &glState,
+                                    bool isCallValid,
+                                    GLenum type,
+                                    GLuint object,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLchar *label,
+                                    angle::ParamCapture *paramCapture);
+void CaptureLabelObjectEXT_label(const State &glState,
+                                 bool isCallValid,
+                                 GLenum type,
+                                 GLuint object,
+                                 GLsizei length,
+                                 const GLchar *label,
+                                 angle::ParamCapture *paramCapture);
+void CaptureInsertEventMarkerEXT_marker(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei length,
+                                        const GLchar *marker,
+                                        angle::ParamCapture *paramCapture);
+void CapturePushGroupMarkerEXT_marker(const State &glState,
+                                      bool isCallValid,
+                                      GLsizei length,
+                                      const GLchar *marker,
+                                      angle::ParamCapture *paramCapture);
+void CaptureDiscardFramebufferEXT_attachments(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              GLsizei numAttachments,
+                                              const GLenum *attachments,
+                                              angle::ParamCapture *paramCapture);
+void CaptureDeleteQueriesEXT_idsPacked(const State &glState,
+                                       bool isCallValid,
+                                       GLsizei n,
+                                       const QueryID *idsPacked,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGenQueriesEXT_idsPacked(const State &glState,
+                                    bool isCallValid,
+                                    GLsizei n,
+                                    QueryID *idsPacked,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetInteger64vEXT_data(const State &glState,
+                                  bool isCallValid,
+                                  GLenum pname,
+                                  GLint64 *data,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjecti64vEXT_params(const State &glState,
+                                         bool isCallValid,
+                                         QueryID idPacked,
+                                         GLenum pname,
+                                         GLint64 *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectivEXT_params(const State &glState,
+                                       bool isCallValid,
+                                       QueryID idPacked,
+                                       GLenum pname,
+                                       GLint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectui64vEXT_params(const State &glState,
+                                          bool isCallValid,
+                                          QueryID idPacked,
+                                          GLenum pname,
+                                          GLuint64 *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectuivEXT_params(const State &glState,
+                                        bool isCallValid,
+                                        QueryID idPacked,
+                                        GLenum pname,
+                                        GLuint *params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetQueryivEXT_params(const State &glState,
+                                 bool isCallValid,
+                                 QueryType targetPacked,
+                                 GLenum pname,
+                                 GLint *params,
+                                 angle::ParamCapture *paramCapture);
+void CaptureDrawBuffersEXT_bufs(const State &glState,
+                                bool isCallValid,
+                                GLsizei n,
+                                const GLenum *bufs,
+                                angle::ParamCapture *paramCapture);
+void CaptureDrawElementsBaseVertexEXT_indices(const State &glState,
+                                              bool isCallValid,
+                                              PrimitiveMode modePacked,
+                                              GLsizei count,
+                                              DrawElementsType typePacked,
+                                              const void *indices,
+                                              GLint basevertex,
+                                              angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedBaseVertexEXT_indices(const State &glState,
+                                                       bool isCallValid,
+                                                       PrimitiveMode modePacked,
+                                                       GLsizei count,
+                                                       DrawElementsType typePacked,
+                                                       const void *indices,
+                                                       GLsizei instancecount,
+                                                       GLint basevertex,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureDrawRangeElementsBaseVertexEXT_indices(const State &glState,
+                                                   bool isCallValid,
+                                                   PrimitiveMode modePacked,
+                                                   GLuint start,
+                                                   GLuint end,
+                                                   GLsizei count,
+                                                   DrawElementsType typePacked,
+                                                   const void *indices,
+                                                   GLint basevertex,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsBaseVertexEXT_count(const State &glState,
+                                                 bool isCallValid,
+                                                 PrimitiveMode modePacked,
+                                                 const GLsizei *count,
+                                                 DrawElementsType typePacked,
+                                                 const void *const *indices,
+                                                 GLsizei primcount,
+                                                 const GLint *basevertex,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsBaseVertexEXT_indices(const State &glState,
+                                                   bool isCallValid,
+                                                   PrimitiveMode modePacked,
+                                                   const GLsizei *count,
+                                                   DrawElementsType typePacked,
+                                                   const void *const *indices,
+                                                   GLsizei primcount,
+                                                   const GLint *basevertex,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsBaseVertexEXT_basevertex(const State &glState,
+                                                      bool isCallValid,
+                                                      PrimitiveMode modePacked,
+                                                      const GLsizei *count,
+                                                      DrawElementsType typePacked,
+                                                      const void *const *indices,
+                                                      GLsizei primcount,
+                                                      const GLint *basevertex,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedEXT_indices(const State &glState,
+                                             bool isCallValid,
+                                             PrimitiveMode modePacked,
+                                             GLsizei count,
+                                             DrawElementsType typePacked,
+                                             const void *indices,
+                                             GLsizei primcount,
+                                             angle::ParamCapture *paramCapture);
+void CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(const State &glState,
+                                                       bool isCallValid,
+                                                       GLsizei n,
+                                                       MemoryObjectID *memoryObjectsPacked,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(const State &glState,
+                                                       bool isCallValid,
+                                                       GLsizei n,
+                                                       const MemoryObjectID *memoryObjectsPacked,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureGetMemoryObjectParameterivEXT_params(const State &glState,
+                                                 bool isCallValid,
+                                                 MemoryObjectID memoryObjectPacked,
+                                                 GLenum pname,
+                                                 GLint *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetUnsignedBytevEXT_data(const State &glState,
+                                     bool isCallValid,
+                                     GLenum pname,
+                                     GLubyte *data,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetUnsignedBytei_vEXT_data(const State &glState,
+                                       bool isCallValid,
+                                       GLenum target,
+                                       GLuint index,
+                                       GLubyte *data,
+                                       angle::ParamCapture *paramCapture);
+void CaptureMemoryObjectParameterivEXT_params(const State &glState,
+                                              bool isCallValid,
+                                              MemoryObjectID memoryObjectPacked,
+                                              GLenum pname,
+                                              const GLint *params,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetnUniformfvEXT_params(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei bufSize,
+                                    GLfloat *params,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetnUniformivEXT_params(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei bufSize,
+                                    GLint *params,
+                                    angle::ParamCapture *paramCapture);
+void CaptureReadnPixelsEXT_data(const State &glState,
+                                bool isCallValid,
+                                GLint x,
+                                GLint y,
+                                GLsizei width,
+                                GLsizei height,
+                                GLenum format,
+                                GLenum type,
+                                GLsizei bufSize,
+                                void *data,
+                                angle::ParamCapture *paramCapture);
+void CaptureDeleteSemaphoresEXT_semaphoresPacked(const State &glState,
+                                                 bool isCallValid,
+                                                 GLsizei n,
+                                                 const SemaphoreID *semaphoresPacked,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGenSemaphoresEXT_semaphoresPacked(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              SemaphoreID *semaphoresPacked,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetSemaphoreParameterui64vEXT_params(const State &glState,
+                                                 bool isCallValid,
+                                                 SemaphoreID semaphorePacked,
+                                                 GLenum pname,
+                                                 GLuint64 *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureSemaphoreParameterui64vEXT_params(const State &glState,
+                                              bool isCallValid,
+                                              SemaphoreID semaphorePacked,
+                                              GLenum pname,
+                                              const GLuint64 *params,
+                                              angle::ParamCapture *paramCapture);
+void CaptureSignalSemaphoreEXT_buffersPacked(const State &glState,
+                                             bool isCallValid,
+                                             SemaphoreID semaphorePacked,
+                                             GLuint numBufferBarriers,
+                                             const BufferID *buffersPacked,
+                                             GLuint numTextureBarriers,
+                                             const TextureID *texturesPacked,
+                                             const GLenum *dstLayouts,
+                                             angle::ParamCapture *paramCapture);
+void CaptureSignalSemaphoreEXT_texturesPacked(const State &glState,
+                                              bool isCallValid,
+                                              SemaphoreID semaphorePacked,
+                                              GLuint numBufferBarriers,
+                                              const BufferID *buffersPacked,
+                                              GLuint numTextureBarriers,
+                                              const TextureID *texturesPacked,
+                                              const GLenum *dstLayouts,
+                                              angle::ParamCapture *paramCapture);
+void CaptureSignalSemaphoreEXT_dstLayouts(const State &glState,
+                                          bool isCallValid,
+                                          SemaphoreID semaphorePacked,
+                                          GLuint numBufferBarriers,
+                                          const BufferID *buffersPacked,
+                                          GLuint numTextureBarriers,
+                                          const TextureID *texturesPacked,
+                                          const GLenum *dstLayouts,
+                                          angle::ParamCapture *paramCapture);
+void CaptureWaitSemaphoreEXT_buffersPacked(const State &glState,
+                                           bool isCallValid,
+                                           SemaphoreID semaphorePacked,
+                                           GLuint numBufferBarriers,
+                                           const BufferID *buffersPacked,
+                                           GLuint numTextureBarriers,
+                                           const TextureID *texturesPacked,
+                                           const GLenum *srcLayouts,
+                                           angle::ParamCapture *paramCapture);
+void CaptureWaitSemaphoreEXT_texturesPacked(const State &glState,
+                                            bool isCallValid,
+                                            SemaphoreID semaphorePacked,
+                                            GLuint numBufferBarriers,
+                                            const BufferID *buffersPacked,
+                                            GLuint numTextureBarriers,
+                                            const TextureID *texturesPacked,
+                                            const GLenum *srcLayouts,
+                                            angle::ParamCapture *paramCapture);
+void CaptureWaitSemaphoreEXT_srcLayouts(const State &glState,
+                                        bool isCallValid,
+                                        SemaphoreID semaphorePacked,
+                                        GLuint numBufferBarriers,
+                                        const BufferID *buffersPacked,
+                                        GLuint numTextureBarriers,
+                                        const TextureID *texturesPacked,
+                                        const GLenum *srcLayouts,
+                                        angle::ParamCapture *paramCapture);
+void CaptureCreateShaderProgramvEXT_strings(const State &glState,
+                                            bool isCallValid,
+                                            ShaderType typePacked,
+                                            GLsizei count,
+                                            const GLchar **strings,
+                                            angle::ParamCapture *paramCapture);
+void CaptureDeleteProgramPipelinesEXT_pipelinesPacked(const State &glState,
+                                                      bool isCallValid,
+                                                      GLsizei n,
+                                                      const ProgramPipelineID *pipelinesPacked,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureGenProgramPipelinesEXT_pipelinesPacked(const State &glState,
+                                                   bool isCallValid,
+                                                   GLsizei n,
+                                                   ProgramPipelineID *pipelinesPacked,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureGetProgramPipelineInfoLogEXT_length(const State &glState,
+                                                bool isCallValid,
+                                                ProgramPipelineID pipelinePacked,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLchar *infoLog,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetProgramPipelineInfoLogEXT_infoLog(const State &glState,
+                                                 bool isCallValid,
+                                                 ProgramPipelineID pipelinePacked,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLchar *infoLog,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetProgramPipelineivEXT_params(const State &glState,
+                                           bool isCallValid,
+                                           ProgramPipelineID pipelinePacked,
+                                           GLenum pname,
+                                           GLint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureProgramUniform1fvEXT_value(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLsizei count,
+                                       const GLfloat *value,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramUniform1ivEXT_value(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLsizei count,
+                                       const GLint *value,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramUniform1uivEXT_value(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        UniformLocation locationPacked,
+                                        GLsizei count,
+                                        const GLuint *value,
+                                        angle::ParamCapture *paramCapture);
+void CaptureProgramUniform2fvEXT_value(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLsizei count,
+                                       const GLfloat *value,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramUniform2ivEXT_value(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLsizei count,
+                                       const GLint *value,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramUniform2uivEXT_value(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        UniformLocation locationPacked,
+                                        GLsizei count,
+                                        const GLuint *value,
+                                        angle::ParamCapture *paramCapture);
+void CaptureProgramUniform3fvEXT_value(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLsizei count,
+                                       const GLfloat *value,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramUniform3ivEXT_value(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLsizei count,
+                                       const GLint *value,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramUniform3uivEXT_value(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        UniformLocation locationPacked,
+                                        GLsizei count,
+                                        const GLuint *value,
+                                        angle::ParamCapture *paramCapture);
+void CaptureProgramUniform4fvEXT_value(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLsizei count,
+                                       const GLfloat *value,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramUniform4ivEXT_value(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLsizei count,
+                                       const GLint *value,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramUniform4uivEXT_value(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        UniformLocation locationPacked,
+                                        GLsizei count,
+                                        const GLuint *value,
+                                        angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2fvEXT_value(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value,
+                                             angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2x3fvEXT_value(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               UniformLocation locationPacked,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value,
+                                               angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2x4fvEXT_value(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               UniformLocation locationPacked,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value,
+                                               angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3fvEXT_value(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value,
+                                             angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3x2fvEXT_value(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               UniformLocation locationPacked,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value,
+                                               angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3x4fvEXT_value(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               UniformLocation locationPacked,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value,
+                                               angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4fvEXT_value(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value,
+                                             angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4x2fvEXT_value(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               UniformLocation locationPacked,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value,
+                                               angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4x3fvEXT_value(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               UniformLocation locationPacked,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIivEXT_params(const State &glState,
+                                             bool isCallValid,
+                                             SamplerID samplerPacked,
+                                             GLenum pname,
+                                             GLint *params,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIuivEXT_params(const State &glState,
+                                              bool isCallValid,
+                                              SamplerID samplerPacked,
+                                              GLenum pname,
+                                              GLuint *params,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIivEXT_params(const State &glState,
+                                         bool isCallValid,
+                                         TextureType targetPacked,
+                                         GLenum pname,
+                                         GLint *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIuivEXT_params(const State &glState,
+                                          bool isCallValid,
+                                          TextureType targetPacked,
+                                          GLenum pname,
+                                          GLuint *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterIivEXT_param(const State &glState,
+                                         bool isCallValid,
+                                         SamplerID samplerPacked,
+                                         GLenum pname,
+                                         const GLint *param,
+                                         angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterIuivEXT_param(const State &glState,
+                                          bool isCallValid,
+                                          SamplerID samplerPacked,
+                                          GLenum pname,
+                                          const GLuint *param,
+                                          angle::ParamCapture *paramCapture);
+void CaptureTexParameterIivEXT_params(const State &glState,
+                                      bool isCallValid,
+                                      TextureType targetPacked,
+                                      GLenum pname,
+                                      const GLint *params,
+                                      angle::ParamCapture *paramCapture);
+void CaptureTexParameterIuivEXT_params(const State &glState,
+                                       bool isCallValid,
+                                       TextureType targetPacked,
+                                       GLenum pname,
+                                       const GLuint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureDebugMessageCallbackKHR_userParam(const State &glState,
+                                              bool isCallValid,
+                                              GLDEBUGPROCKHR callback,
+                                              const void *userParam,
+                                              angle::ParamCapture *paramCapture);
+void CaptureDebugMessageControlKHR_ids(const State &glState,
+                                       bool isCallValid,
+                                       GLenum source,
+                                       GLenum type,
+                                       GLenum severity,
+                                       GLsizei count,
+                                       const GLuint *ids,
+                                       GLboolean enabled,
+                                       angle::ParamCapture *paramCapture);
+void CaptureDebugMessageInsertKHR_buf(const State &glState,
+                                      bool isCallValid,
+                                      GLenum source,
+                                      GLenum type,
+                                      GLuint id,
+                                      GLenum severity,
+                                      GLsizei length,
+                                      const GLchar *buf,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLogKHR_sources(const State &glState,
+                                          bool isCallValid,
+                                          GLuint count,
+                                          GLsizei bufSize,
+                                          GLenum *sources,
+                                          GLenum *types,
+                                          GLuint *ids,
+                                          GLenum *severities,
+                                          GLsizei *lengths,
+                                          GLchar *messageLog,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLogKHR_types(const State &glState,
+                                        bool isCallValid,
+                                        GLuint count,
+                                        GLsizei bufSize,
+                                        GLenum *sources,
+                                        GLenum *types,
+                                        GLuint *ids,
+                                        GLenum *severities,
+                                        GLsizei *lengths,
+                                        GLchar *messageLog,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLogKHR_ids(const State &glState,
+                                      bool isCallValid,
+                                      GLuint count,
+                                      GLsizei bufSize,
+                                      GLenum *sources,
+                                      GLenum *types,
+                                      GLuint *ids,
+                                      GLenum *severities,
+                                      GLsizei *lengths,
+                                      GLchar *messageLog,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLogKHR_severities(const State &glState,
+                                             bool isCallValid,
+                                             GLuint count,
+                                             GLsizei bufSize,
+                                             GLenum *sources,
+                                             GLenum *types,
+                                             GLuint *ids,
+                                             GLenum *severities,
+                                             GLsizei *lengths,
+                                             GLchar *messageLog,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLogKHR_lengths(const State &glState,
+                                          bool isCallValid,
+                                          GLuint count,
+                                          GLsizei bufSize,
+                                          GLenum *sources,
+                                          GLenum *types,
+                                          GLuint *ids,
+                                          GLenum *severities,
+                                          GLsizei *lengths,
+                                          GLchar *messageLog,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetDebugMessageLogKHR_messageLog(const State &glState,
+                                             bool isCallValid,
+                                             GLuint count,
+                                             GLsizei bufSize,
+                                             GLenum *sources,
+                                             GLenum *types,
+                                             GLuint *ids,
+                                             GLenum *severities,
+                                             GLsizei *lengths,
+                                             GLchar *messageLog,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetObjectLabelKHR_length(const State &glState,
+                                     bool isCallValid,
+                                     GLenum identifier,
+                                     GLuint name,
+                                     GLsizei bufSize,
+                                     GLsizei *length,
+                                     GLchar *label,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetObjectLabelKHR_label(const State &glState,
+                                    bool isCallValid,
+                                    GLenum identifier,
+                                    GLuint name,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLchar *label,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetObjectPtrLabelKHR_ptr(const State &glState,
+                                     bool isCallValid,
+                                     const void *ptr,
+                                     GLsizei bufSize,
+                                     GLsizei *length,
+                                     GLchar *label,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetObjectPtrLabelKHR_length(const State &glState,
+                                        bool isCallValid,
+                                        const void *ptr,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLchar *label,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetObjectPtrLabelKHR_label(const State &glState,
+                                       bool isCallValid,
+                                       const void *ptr,
+                                       GLsizei bufSize,
+                                       GLsizei *length,
+                                       GLchar *label,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetPointervKHR_params(const State &glState,
+                                  bool isCallValid,
+                                  GLenum pname,
+                                  void **params,
+                                  angle::ParamCapture *paramCapture);
+void CaptureObjectLabelKHR_label(const State &glState,
+                                 bool isCallValid,
+                                 GLenum identifier,
+                                 GLuint name,
+                                 GLsizei length,
+                                 const GLchar *label,
+                                 angle::ParamCapture *paramCapture);
+void CaptureObjectPtrLabelKHR_ptr(const State &glState,
+                                  bool isCallValid,
+                                  const void *ptr,
+                                  GLsizei length,
+                                  const GLchar *label,
+                                  angle::ParamCapture *paramCapture);
+void CaptureObjectPtrLabelKHR_label(const State &glState,
+                                    bool isCallValid,
+                                    const void *ptr,
+                                    GLsizei length,
+                                    const GLchar *label,
+                                    angle::ParamCapture *paramCapture);
+void CapturePushDebugGroupKHR_message(const State &glState,
+                                      bool isCallValid,
+                                      GLenum source,
+                                      GLuint id,
+                                      GLsizei length,
+                                      const GLchar *message,
+                                      angle::ParamCapture *paramCapture);
+void CaptureDeleteFencesNV_fencesPacked(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        const FenceNVID *fencesPacked,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGenFencesNV_fencesPacked(const State &glState,
+                                     bool isCallValid,
+                                     GLsizei n,
+                                     FenceNVID *fencesPacked,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetFenceivNV_params(const State &glState,
+                                bool isCallValid,
+                                FenceNVID fencePacked,
+                                GLenum pname,
+                                GLint *params,
+                                angle::ParamCapture *paramCapture);
+void CaptureDrawElementsBaseVertexOES_indices(const State &glState,
+                                              bool isCallValid,
+                                              PrimitiveMode modePacked,
+                                              GLsizei count,
+                                              DrawElementsType typePacked,
+                                              const void *indices,
+                                              GLint basevertex,
+                                              angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedBaseVertexOES_indices(const State &glState,
+                                                       bool isCallValid,
+                                                       PrimitiveMode modePacked,
+                                                       GLsizei count,
+                                                       DrawElementsType typePacked,
+                                                       const void *indices,
+                                                       GLsizei instancecount,
+                                                       GLint basevertex,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureDrawRangeElementsBaseVertexOES_indices(const State &glState,
+                                                   bool isCallValid,
+                                                   PrimitiveMode modePacked,
+                                                   GLuint start,
+                                                   GLuint end,
+                                                   GLsizei count,
+                                                   DrawElementsType typePacked,
+                                                   const void *indices,
+                                                   GLint basevertex,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureDrawTexfvOES_coords(const State &glState,
+                                bool isCallValid,
+                                const GLfloat *coords,
+                                angle::ParamCapture *paramCapture);
+void CaptureDrawTexivOES_coords(const State &glState,
+                                bool isCallValid,
+                                const GLint *coords,
+                                angle::ParamCapture *paramCapture);
+void CaptureDrawTexsvOES_coords(const State &glState,
+                                bool isCallValid,
+                                const GLshort *coords,
+                                angle::ParamCapture *paramCapture);
+void CaptureDrawTexxvOES_coords(const State &glState,
+                                bool isCallValid,
+                                const GLfixed *coords,
+                                angle::ParamCapture *paramCapture);
+void CaptureDeleteFramebuffersOES_framebuffersPacked(const State &glState,
+                                                     bool isCallValid,
+                                                     GLsizei n,
+                                                     const FramebufferID *framebuffersPacked,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureDeleteRenderbuffersOES_renderbuffersPacked(const State &glState,
+                                                       bool isCallValid,
+                                                       GLsizei n,
+                                                       const RenderbufferID *renderbuffersPacked,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureGenFramebuffersOES_framebuffersPacked(const State &glState,
+                                                  bool isCallValid,
+                                                  GLsizei n,
+                                                  FramebufferID *framebuffersPacked,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGenRenderbuffersOES_renderbuffersPacked(const State &glState,
+                                                    bool isCallValid,
+                                                    GLsizei n,
+                                                    RenderbufferID *renderbuffersPacked,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureGetFramebufferAttachmentParameterivOES_params(const State &glState,
+                                                          bool isCallValid,
+                                                          GLenum target,
+                                                          GLenum attachment,
+                                                          GLenum pname,
+                                                          GLint *params,
+                                                          angle::ParamCapture *paramCapture);
+void CaptureGetRenderbufferParameterivOES_params(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum target,
+                                                 GLenum pname,
+                                                 GLint *params,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetProgramBinaryOES_length(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       GLsizei bufSize,
+                                       GLsizei *length,
+                                       GLenum *binaryFormat,
+                                       void *binary,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetProgramBinaryOES_binaryFormat(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLenum *binaryFormat,
+                                             void *binary,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetProgramBinaryOES_binary(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       GLsizei bufSize,
+                                       GLsizei *length,
+                                       GLenum *binaryFormat,
+                                       void *binary,
+                                       angle::ParamCapture *paramCapture);
+void CaptureProgramBinaryOES_binary(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    GLenum binaryFormat,
+                                    const void *binary,
+                                    GLint length,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetBufferPointervOES_params(const State &glState,
+                                        bool isCallValid,
+                                        BufferBinding targetPacked,
+                                        GLenum pname,
+                                        void **params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureMatrixIndexPointerOES_pointer(const State &glState,
+                                          bool isCallValid,
+                                          GLint size,
+                                          GLenum type,
+                                          GLsizei stride,
+                                          const void *pointer,
+                                          angle::ParamCapture *paramCapture);
+void CaptureWeightPointerOES_pointer(const State &glState,
+                                     bool isCallValid,
+                                     GLint size,
+                                     GLenum type,
+                                     GLsizei stride,
+                                     const void *pointer,
+                                     angle::ParamCapture *paramCapture);
+void CapturePointSizePointerOES_pointer(const State &glState,
+                                        bool isCallValid,
+                                        VertexAttribType typePacked,
+                                        GLsizei stride,
+                                        const void *pointer,
+                                        angle::ParamCapture *paramCapture);
+void CaptureQueryMatrixxOES_mantissa(const State &glState,
+                                     bool isCallValid,
+                                     GLfixed *mantissa,
+                                     GLint *exponent,
+                                     angle::ParamCapture *paramCapture);
+void CaptureQueryMatrixxOES_exponent(const State &glState,
+                                     bool isCallValid,
+                                     GLfixed *mantissa,
+                                     GLint *exponent,
+                                     angle::ParamCapture *paramCapture);
+void CaptureCompressedTexImage3DOES_data(const State &glState,
+                                         bool isCallValid,
+                                         TextureTarget targetPacked,
+                                         GLint level,
+                                         GLenum internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLint border,
+                                         GLsizei imageSize,
+                                         const void *data,
+                                         angle::ParamCapture *paramCapture);
+void CaptureCompressedTexSubImage3DOES_data(const State &glState,
+                                            bool isCallValid,
+                                            TextureTarget targetPacked,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLsizei imageSize,
+                                            const void *data,
+                                            angle::ParamCapture *paramCapture);
+void CaptureTexImage3DOES_pixels(const State &glState,
+                                 bool isCallValid,
+                                 TextureTarget targetPacked,
+                                 GLint level,
+                                 GLenum internalformat,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLsizei depth,
+                                 GLint border,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void *pixels,
+                                 angle::ParamCapture *paramCapture);
+void CaptureTexSubImage3DOES_pixels(const State &glState,
+                                    bool isCallValid,
+                                    TextureTarget targetPacked,
+                                    GLint level,
+                                    GLint xoffset,
+                                    GLint yoffset,
+                                    GLint zoffset,
+                                    GLsizei width,
+                                    GLsizei height,
+                                    GLsizei depth,
+                                    GLenum format,
+                                    GLenum type,
+                                    const void *pixels,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIivOES_params(const State &glState,
+                                             bool isCallValid,
+                                             SamplerID samplerPacked,
+                                             GLenum pname,
+                                             GLint *params,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetSamplerParameterIuivOES_params(const State &glState,
+                                              bool isCallValid,
+                                              SamplerID samplerPacked,
+                                              GLenum pname,
+                                              GLuint *params,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIivOES_params(const State &glState,
+                                         bool isCallValid,
+                                         TextureType targetPacked,
+                                         GLenum pname,
+                                         GLint *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetTexParameterIuivOES_params(const State &glState,
+                                          bool isCallValid,
+                                          TextureType targetPacked,
+                                          GLenum pname,
+                                          GLuint *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterIivOES_param(const State &glState,
+                                         bool isCallValid,
+                                         SamplerID samplerPacked,
+                                         GLenum pname,
+                                         const GLint *param,
+                                         angle::ParamCapture *paramCapture);
+void CaptureSamplerParameterIuivOES_param(const State &glState,
+                                          bool isCallValid,
+                                          SamplerID samplerPacked,
+                                          GLenum pname,
+                                          const GLuint *param,
+                                          angle::ParamCapture *paramCapture);
+void CaptureTexParameterIivOES_params(const State &glState,
+                                      bool isCallValid,
+                                      TextureType targetPacked,
+                                      GLenum pname,
+                                      const GLint *params,
+                                      angle::ParamCapture *paramCapture);
+void CaptureTexParameterIuivOES_params(const State &glState,
+                                       bool isCallValid,
+                                       TextureType targetPacked,
+                                       GLenum pname,
+                                       const GLuint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetTexGenfvOES_params(const State &glState,
+                                  bool isCallValid,
+                                  GLenum coord,
+                                  GLenum pname,
+                                  GLfloat *params,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetTexGenivOES_params(const State &glState,
+                                  bool isCallValid,
+                                  GLenum coord,
+                                  GLenum pname,
+                                  GLint *params,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetTexGenxvOES_params(const State &glState,
+                                  bool isCallValid,
+                                  GLenum coord,
+                                  GLenum pname,
+                                  GLfixed *params,
+                                  angle::ParamCapture *paramCapture);
+void CaptureTexGenfvOES_params(const State &glState,
+                               bool isCallValid,
+                               GLenum coord,
+                               GLenum pname,
+                               const GLfloat *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureTexGenivOES_params(const State &glState,
+                               bool isCallValid,
+                               GLenum coord,
+                               GLenum pname,
+                               const GLint *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureTexGenxvOES_params(const State &glState,
+                               bool isCallValid,
+                               GLenum coord,
+                               GLenum pname,
+                               const GLfixed *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureDeleteVertexArraysOES_arraysPacked(const State &glState,
+                                               bool isCallValid,
+                                               GLsizei n,
+                                               const VertexArrayID *arraysPacked,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGenVertexArraysOES_arraysPacked(const State &glState,
+                                            bool isCallValid,
+                                            GLsizei n,
+                                            VertexArrayID *arraysPacked,
+                                            angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GLES_EXT_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils.h b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils.h
new file mode 100644
index 0000000000..18e2fe41cc
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils.h
@@ -0,0 +1,23 @@
+//
+// 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.
+//
+// frame_capture_utils.h:
+//   ANGLE frame capture utils interface.
+//
+#ifndef FRAME_CAPTURE_UTILS_H_
+#define FRAME_CAPTURE_UTILS_H_
+
+#include "libANGLE/Error.h"
+
+namespace gl
+{
+class Context;
+}  // namespace gl
+
+namespace angle
+{
+Result SerializeContextToString(const gl::Context *context, std::string *stringOut);
+}  // namespace angle
+#endif  // FRAME_CAPTURE_UTILS_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_autogen.h
new file mode 100644
index 0000000000..dfbf991bcd
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_autogen.h
@@ -0,0 +1,2546 @@
+// 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.
+//
+// frame_capture_utils_autogen.h:
+//   ANGLE Frame capture types and helper functions.
+
+#ifndef LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_
+#define LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+
+namespace angle
+{
+enum class ParamType
+{
+    TAlphaTestFunc,
+    TBufferBinding,
+    TBufferID,
+    TBufferIDConstPointer,
+    TBufferIDPointer,
+    TBufferUsage,
+    TClientVertexArrayType,
+    TCullFaceMode,
+    TDrawElementsType,
+    TFenceNVID,
+    TFenceNVIDConstPointer,
+    TFenceNVIDPointer,
+    TFramebufferID,
+    TFramebufferIDConstPointer,
+    TFramebufferIDPointer,
+    TGLDEBUGPROC,
+    TGLDEBUGPROCKHR,
+    TGLbitfield,
+    TGLboolean,
+    TGLbooleanConstPointer,
+    TGLbooleanPointer,
+    TGLbyte,
+    TGLbyteConstPointer,
+    TGLcharConstPointer,
+    TGLcharConstPointerPointer,
+    TGLcharPointer,
+    TGLclampx,
+    TGLdouble,
+    TGLdoubleConstPointer,
+    TGLdoublePointer,
+    TGLeglClientBufferEXT,
+    TGLeglImageOES,
+    TGLenum,
+    TGLenumConstPointer,
+    TGLenumPointer,
+    TGLfixed,
+    TGLfixedConstPointer,
+    TGLfixedPointer,
+    TGLfloat,
+    TGLfloatConstPointer,
+    TGLfloatPointer,
+    TGLint,
+    TGLint64Pointer,
+    TGLintConstPointer,
+    TGLintPointer,
+    TGLintptr,
+    TGLintptrConstPointer,
+    TGLshort,
+    TGLshortConstPointer,
+    TGLsizei,
+    TGLsizeiConstPointer,
+    TGLsizeiPointer,
+    TGLsizeiptr,
+    TGLsizeiptrConstPointer,
+    TGLsync,
+    TGLubyte,
+    TGLubyteConstPointer,
+    TGLubytePointer,
+    TGLuint,
+    TGLuint64,
+    TGLuint64ConstPointer,
+    TGLuint64Pointer,
+    TGLuintConstPointer,
+    TGLuintPointer,
+    TGLushort,
+    TGLushortConstPointer,
+    TGLushortPointer,
+    TGLvoidConstPointer,
+    TGLvoidConstPointerPointer,
+    TGraphicsResetStatus,
+    THandleType,
+    TLightParameter,
+    TLogicalOperation,
+    TMaterialParameter,
+    TMatrixType,
+    TMemoryObjectID,
+    TMemoryObjectIDConstPointer,
+    TMemoryObjectIDPointer,
+    TPointParameter,
+    TPrimitiveMode,
+    TProgramPipelineID,
+    TProgramPipelineIDConstPointer,
+    TProgramPipelineIDPointer,
+    TProvokingVertexConvention,
+    TQueryID,
+    TQueryIDConstPointer,
+    TQueryIDPointer,
+    TQueryType,
+    TRenderbufferID,
+    TRenderbufferIDConstPointer,
+    TRenderbufferIDPointer,
+    TSamplerID,
+    TSamplerIDConstPointer,
+    TSamplerIDPointer,
+    TSemaphoreID,
+    TSemaphoreIDConstPointer,
+    TSemaphoreIDPointer,
+    TShaderProgramID,
+    TShaderProgramIDConstPointer,
+    TShaderProgramIDPointer,
+    TShaderType,
+    TShadingModel,
+    TTextureEnvParameter,
+    TTextureEnvTarget,
+    TTextureID,
+    TTextureIDConstPointer,
+    TTextureIDPointer,
+    TTextureTarget,
+    TTextureType,
+    TTransformFeedbackID,
+    TTransformFeedbackIDConstPointer,
+    TTransformFeedbackIDPointer,
+    TUniformBlockIndex,
+    TUniformLocation,
+    TVertexArrayID,
+    TVertexArrayIDConstPointer,
+    TVertexArrayIDPointer,
+    TVertexAttribType,
+    TvoidConstPointer,
+    TvoidConstPointerPointer,
+    TvoidPointer,
+    TvoidPointerPointer,
+};
+
+constexpr uint32_t kParamTypeCount = 122;
+
+union ParamValue
+{
+    gl::AlphaTestFunc AlphaTestFuncVal;
+    gl::BufferBinding BufferBindingVal;
+    gl::BufferID BufferIDVal;
+    const gl::BufferID *BufferIDConstPointerVal;
+    gl::BufferID *BufferIDPointerVal;
+    gl::BufferUsage BufferUsageVal;
+    gl::ClientVertexArrayType ClientVertexArrayTypeVal;
+    gl::CullFaceMode CullFaceModeVal;
+    gl::DrawElementsType DrawElementsTypeVal;
+    gl::FenceNVID FenceNVIDVal;
+    const gl::FenceNVID *FenceNVIDConstPointerVal;
+    gl::FenceNVID *FenceNVIDPointerVal;
+    gl::FramebufferID FramebufferIDVal;
+    const gl::FramebufferID *FramebufferIDConstPointerVal;
+    gl::FramebufferID *FramebufferIDPointerVal;
+    GLDEBUGPROC GLDEBUGPROCVal;
+    GLDEBUGPROCKHR GLDEBUGPROCKHRVal;
+    GLbitfield GLbitfieldVal;
+    GLboolean GLbooleanVal;
+    const GLboolean *GLbooleanConstPointerVal;
+    GLboolean *GLbooleanPointerVal;
+    GLbyte GLbyteVal;
+    const GLbyte *GLbyteConstPointerVal;
+    const GLchar *GLcharConstPointerVal;
+    const GLchar *const *GLcharConstPointerPointerVal;
+    GLchar *GLcharPointerVal;
+    GLclampx GLclampxVal;
+    GLdouble GLdoubleVal;
+    const GLdouble *GLdoubleConstPointerVal;
+    GLdouble *GLdoublePointerVal;
+    GLeglClientBufferEXT GLeglClientBufferEXTVal;
+    GLeglImageOES GLeglImageOESVal;
+    GLenum GLenumVal;
+    const GLenum *GLenumConstPointerVal;
+    GLenum *GLenumPointerVal;
+    GLfixed GLfixedVal;
+    const GLfixed *GLfixedConstPointerVal;
+    GLfixed *GLfixedPointerVal;
+    GLfloat GLfloatVal;
+    const GLfloat *GLfloatConstPointerVal;
+    GLfloat *GLfloatPointerVal;
+    GLint GLintVal;
+    GLint64 *GLint64PointerVal;
+    const GLint *GLintConstPointerVal;
+    GLint *GLintPointerVal;
+    GLintptr GLintptrVal;
+    const GLintptr *GLintptrConstPointerVal;
+    GLshort GLshortVal;
+    const GLshort *GLshortConstPointerVal;
+    GLsizei GLsizeiVal;
+    const GLsizei *GLsizeiConstPointerVal;
+    GLsizei *GLsizeiPointerVal;
+    GLsizeiptr GLsizeiptrVal;
+    const GLsizeiptr *GLsizeiptrConstPointerVal;
+    GLsync GLsyncVal;
+    GLubyte GLubyteVal;
+    const GLubyte *GLubyteConstPointerVal;
+    GLubyte *GLubytePointerVal;
+    GLuint GLuintVal;
+    GLuint64 GLuint64Val;
+    const GLuint64 *GLuint64ConstPointerVal;
+    GLuint64 *GLuint64PointerVal;
+    const GLuint *GLuintConstPointerVal;
+    GLuint *GLuintPointerVal;
+    GLushort GLushortVal;
+    const GLushort *GLushortConstPointerVal;
+    GLushort *GLushortPointerVal;
+    const GLvoid *GLvoidConstPointerVal;
+    const GLvoid *const *GLvoidConstPointerPointerVal;
+    gl::GraphicsResetStatus GraphicsResetStatusVal;
+    gl::HandleType HandleTypeVal;
+    gl::LightParameter LightParameterVal;
+    gl::LogicalOperation LogicalOperationVal;
+    gl::MaterialParameter MaterialParameterVal;
+    gl::MatrixType MatrixTypeVal;
+    gl::MemoryObjectID MemoryObjectIDVal;
+    const gl::MemoryObjectID *MemoryObjectIDConstPointerVal;
+    gl::MemoryObjectID *MemoryObjectIDPointerVal;
+    gl::PointParameter PointParameterVal;
+    gl::PrimitiveMode PrimitiveModeVal;
+    gl::ProgramPipelineID ProgramPipelineIDVal;
+    const gl::ProgramPipelineID *ProgramPipelineIDConstPointerVal;
+    gl::ProgramPipelineID *ProgramPipelineIDPointerVal;
+    gl::ProvokingVertexConvention ProvokingVertexConventionVal;
+    gl::QueryID QueryIDVal;
+    const gl::QueryID *QueryIDConstPointerVal;
+    gl::QueryID *QueryIDPointerVal;
+    gl::QueryType QueryTypeVal;
+    gl::RenderbufferID RenderbufferIDVal;
+    const gl::RenderbufferID *RenderbufferIDConstPointerVal;
+    gl::RenderbufferID *RenderbufferIDPointerVal;
+    gl::SamplerID SamplerIDVal;
+    const gl::SamplerID *SamplerIDConstPointerVal;
+    gl::SamplerID *SamplerIDPointerVal;
+    gl::SemaphoreID SemaphoreIDVal;
+    const gl::SemaphoreID *SemaphoreIDConstPointerVal;
+    gl::SemaphoreID *SemaphoreIDPointerVal;
+    gl::ShaderProgramID ShaderProgramIDVal;
+    const gl::ShaderProgramID *ShaderProgramIDConstPointerVal;
+    gl::ShaderProgramID *ShaderProgramIDPointerVal;
+    gl::ShaderType ShaderTypeVal;
+    gl::ShadingModel ShadingModelVal;
+    gl::TextureEnvParameter TextureEnvParameterVal;
+    gl::TextureEnvTarget TextureEnvTargetVal;
+    gl::TextureID TextureIDVal;
+    const gl::TextureID *TextureIDConstPointerVal;
+    gl::TextureID *TextureIDPointerVal;
+    gl::TextureTarget TextureTargetVal;
+    gl::TextureType TextureTypeVal;
+    gl::TransformFeedbackID TransformFeedbackIDVal;
+    const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal;
+    gl::TransformFeedbackID *TransformFeedbackIDPointerVal;
+    gl::UniformBlockIndex UniformBlockIndexVal;
+    gl::UniformLocation UniformLocationVal;
+    gl::VertexArrayID VertexArrayIDVal;
+    const gl::VertexArrayID *VertexArrayIDConstPointerVal;
+    gl::VertexArrayID *VertexArrayIDPointerVal;
+    gl::VertexAttribType VertexAttribTypeVal;
+    const void *voidConstPointerVal;
+    const void *const *voidConstPointerPointerVal;
+    void *voidPointerVal;
+    void **voidPointerPointerVal;
+};
+
+template <ParamType PType, typename T>
+T GetParamVal(const ParamValue &value);
+
+template <>
+inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>(
+    const ParamValue &value)
+{
+    return value.AlphaTestFuncVal;
+}
+
+template <>
+inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>(
+    const ParamValue &value)
+{
+    return value.BufferBindingVal;
+}
+
+template <>
+inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value)
+{
+    return value.BufferIDVal;
+}
+
+template <>
+inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>(
+    const ParamValue &value)
+{
+    return value.BufferIDConstPointerVal;
+}
+
+template <>
+inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>(
+    const ParamValue &value)
+{
+    return value.BufferIDPointerVal;
+}
+
+template <>
+inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>(
+    const ParamValue &value)
+{
+    return value.BufferUsageVal;
+}
+
+template <>
+inline gl::ClientVertexArrayType
+GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value)
+{
+    return value.ClientVertexArrayTypeVal;
+}
+
+template <>
+inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>(
+    const ParamValue &value)
+{
+    return value.CullFaceModeVal;
+}
+
+template <>
+inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>(
+    const ParamValue &value)
+{
+    return value.DrawElementsTypeVal;
+}
+
+template <>
+inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value)
+{
+    return value.FenceNVIDVal;
+}
+
+template <>
+inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>(
+    const ParamValue &value)
+{
+    return value.FenceNVIDConstPointerVal;
+}
+
+template <>
+inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>(
+    const ParamValue &value)
+{
+    return value.FenceNVIDPointerVal;
+}
+
+template <>
+inline gl::FramebufferID GetParamVal<ParamType::TFramebufferID, gl::FramebufferID>(
+    const ParamValue &value)
+{
+    return value.FramebufferIDVal;
+}
+
+template <>
+inline const gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDConstPointer,
+                                            const gl::FramebufferID *>(const ParamValue &value)
+{
+    return value.FramebufferIDConstPointerVal;
+}
+
+template <>
+inline gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDPointer, gl::FramebufferID *>(
+    const ParamValue &value)
+{
+    return value.FramebufferIDPointerVal;
+}
+
+template <>
+inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value)
+{
+    return value.GLDEBUGPROCVal;
+}
+
+template <>
+inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
+    const ParamValue &value)
+{
+    return value.GLDEBUGPROCKHRVal;
+}
+
+template <>
+inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
+{
+    return value.GLbitfieldVal;
+}
+
+template <>
+inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value)
+{
+    return value.GLbooleanVal;
+}
+
+template <>
+inline const GLboolean *GetParamVal<ParamType::TGLbooleanConstPointer, const GLboolean *>(
+    const ParamValue &value)
+{
+    return value.GLbooleanConstPointerVal;
+}
+
+template <>
+inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value)
+{
+    return value.GLbooleanPointerVal;
+}
+
+template <>
+inline GLbyte GetParamVal<ParamType::TGLbyte, GLbyte>(const ParamValue &value)
+{
+    return value.GLbyteVal;
+}
+
+template <>
+inline const GLbyte *GetParamVal<ParamType::TGLbyteConstPointer, const GLbyte *>(
+    const ParamValue &value)
+{
+    return value.GLbyteConstPointerVal;
+}
+
+template <>
+inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>(
+    const ParamValue &value)
+{
+    return value.GLcharConstPointerVal;
+}
+
+template <>
+inline const GLchar *const *
+GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value)
+{
+    return value.GLcharConstPointerPointerVal;
+}
+
+template <>
+inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value)
+{
+    return value.GLcharPointerVal;
+}
+
+template <>
+inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value)
+{
+    return value.GLclampxVal;
+}
+
+template <>
+inline GLdouble GetParamVal<ParamType::TGLdouble, GLdouble>(const ParamValue &value)
+{
+    return value.GLdoubleVal;
+}
+
+template <>
+inline const GLdouble *GetParamVal<ParamType::TGLdoubleConstPointer, const GLdouble *>(
+    const ParamValue &value)
+{
+    return value.GLdoubleConstPointerVal;
+}
+
+template <>
+inline GLdouble *GetParamVal<ParamType::TGLdoublePointer, GLdouble *>(const ParamValue &value)
+{
+    return value.GLdoublePointerVal;
+}
+
+template <>
+inline GLeglClientBufferEXT GetParamVal<ParamType::TGLeglClientBufferEXT, GLeglClientBufferEXT>(
+    const ParamValue &value)
+{
+    return value.GLeglClientBufferEXTVal;
+}
+
+template <>
+inline GLeglImageOES GetParamVal<ParamType::TGLeglImageOES, GLeglImageOES>(const ParamValue &value)
+{
+    return value.GLeglImageOESVal;
+}
+
+template <>
+inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value)
+{
+    return value.GLenumVal;
+}
+
+template <>
+inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>(
+    const ParamValue &value)
+{
+    return value.GLenumConstPointerVal;
+}
+
+template <>
+inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value)
+{
+    return value.GLenumPointerVal;
+}
+
+template <>
+inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value)
+{
+    return value.GLfixedVal;
+}
+
+template <>
+inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>(
+    const ParamValue &value)
+{
+    return value.GLfixedConstPointerVal;
+}
+
+template <>
+inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value)
+{
+    return value.GLfixedPointerVal;
+}
+
+template <>
+inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value)
+{
+    return value.GLfloatVal;
+}
+
+template <>
+inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>(
+    const ParamValue &value)
+{
+    return value.GLfloatConstPointerVal;
+}
+
+template <>
+inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value)
+{
+    return value.GLfloatPointerVal;
+}
+
+template <>
+inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value)
+{
+    return value.GLintVal;
+}
+
+template <>
+inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value)
+{
+    return value.GLint64PointerVal;
+}
+
+template <>
+inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>(
+    const ParamValue &value)
+{
+    return value.GLintConstPointerVal;
+}
+
+template <>
+inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value)
+{
+    return value.GLintPointerVal;
+}
+
+template <>
+inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value)
+{
+    return value.GLintptrVal;
+}
+
+template <>
+inline const GLintptr *GetParamVal<ParamType::TGLintptrConstPointer, const GLintptr *>(
+    const ParamValue &value)
+{
+    return value.GLintptrConstPointerVal;
+}
+
+template <>
+inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value)
+{
+    return value.GLshortVal;
+}
+
+template <>
+inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>(
+    const ParamValue &value)
+{
+    return value.GLshortConstPointerVal;
+}
+
+template <>
+inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value)
+{
+    return value.GLsizeiVal;
+}
+
+template <>
+inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>(
+    const ParamValue &value)
+{
+    return value.GLsizeiConstPointerVal;
+}
+
+template <>
+inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value)
+{
+    return value.GLsizeiPointerVal;
+}
+
+template <>
+inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value)
+{
+    return value.GLsizeiptrVal;
+}
+
+template <>
+inline const GLsizeiptr *GetParamVal<ParamType::TGLsizeiptrConstPointer, const GLsizeiptr *>(
+    const ParamValue &value)
+{
+    return value.GLsizeiptrConstPointerVal;
+}
+
+template <>
+inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value)
+{
+    return value.GLsyncVal;
+}
+
+template <>
+inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value)
+{
+    return value.GLubyteVal;
+}
+
+template <>
+inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>(
+    const ParamValue &value)
+{
+    return value.GLubyteConstPointerVal;
+}
+
+template <>
+inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value)
+{
+    return value.GLubytePointerVal;
+}
+
+template <>
+inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value)
+{
+    return value.GLuintVal;
+}
+
+template <>
+inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value)
+{
+    return value.GLuint64Val;
+}
+
+template <>
+inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>(
+    const ParamValue &value)
+{
+    return value.GLuint64ConstPointerVal;
+}
+
+template <>
+inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value)
+{
+    return value.GLuint64PointerVal;
+}
+
+template <>
+inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>(
+    const ParamValue &value)
+{
+    return value.GLuintConstPointerVal;
+}
+
+template <>
+inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value)
+{
+    return value.GLuintPointerVal;
+}
+
+template <>
+inline GLushort GetParamVal<ParamType::TGLushort, GLushort>(const ParamValue &value)
+{
+    return value.GLushortVal;
+}
+
+template <>
+inline const GLushort *GetParamVal<ParamType::TGLushortConstPointer, const GLushort *>(
+    const ParamValue &value)
+{
+    return value.GLushortConstPointerVal;
+}
+
+template <>
+inline GLushort *GetParamVal<ParamType::TGLushortPointer, GLushort *>(const ParamValue &value)
+{
+    return value.GLushortPointerVal;
+}
+
+template <>
+inline const GLvoid *GetParamVal<ParamType::TGLvoidConstPointer, const GLvoid *>(
+    const ParamValue &value)
+{
+    return value.GLvoidConstPointerVal;
+}
+
+template <>
+inline const GLvoid *const *
+GetParamVal<ParamType::TGLvoidConstPointerPointer, const GLvoid *const *>(const ParamValue &value)
+{
+    return value.GLvoidConstPointerPointerVal;
+}
+
+template <>
+inline gl::GraphicsResetStatus
+GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value)
+{
+    return value.GraphicsResetStatusVal;
+}
+
+template <>
+inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value)
+{
+    return value.HandleTypeVal;
+}
+
+template <>
+inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>(
+    const ParamValue &value)
+{
+    return value.LightParameterVal;
+}
+
+template <>
+inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>(
+    const ParamValue &value)
+{
+    return value.LogicalOperationVal;
+}
+
+template <>
+inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>(
+    const ParamValue &value)
+{
+    return value.MaterialParameterVal;
+}
+
+template <>
+inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value)
+{
+    return value.MatrixTypeVal;
+}
+
+template <>
+inline gl::MemoryObjectID GetParamVal<ParamType::TMemoryObjectID, gl::MemoryObjectID>(
+    const ParamValue &value)
+{
+    return value.MemoryObjectIDVal;
+}
+
+template <>
+inline const gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDConstPointer,
+                                             const gl::MemoryObjectID *>(const ParamValue &value)
+{
+    return value.MemoryObjectIDConstPointerVal;
+}
+
+template <>
+inline gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDPointer, gl::MemoryObjectID *>(
+    const ParamValue &value)
+{
+    return value.MemoryObjectIDPointerVal;
+}
+
+template <>
+inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
+    const ParamValue &value)
+{
+    return value.PointParameterVal;
+}
+
+template <>
+inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>(
+    const ParamValue &value)
+{
+    return value.PrimitiveModeVal;
+}
+
+template <>
+inline gl::ProgramPipelineID GetParamVal<ParamType::TProgramPipelineID, gl::ProgramPipelineID>(
+    const ParamValue &value)
+{
+    return value.ProgramPipelineIDVal;
+}
+
+template <>
+inline const gl::ProgramPipelineID *
+GetParamVal<ParamType::TProgramPipelineIDConstPointer, const gl::ProgramPipelineID *>(
+    const ParamValue &value)
+{
+    return value.ProgramPipelineIDConstPointerVal;
+}
+
+template <>
+inline gl::ProgramPipelineID *
+GetParamVal<ParamType::TProgramPipelineIDPointer, gl::ProgramPipelineID *>(const ParamValue &value)
+{
+    return value.ProgramPipelineIDPointerVal;
+}
+
+template <>
+inline gl::ProvokingVertexConvention
+GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>(
+    const ParamValue &value)
+{
+    return value.ProvokingVertexConventionVal;
+}
+
+template <>
+inline gl::QueryID GetParamVal<ParamType::TQueryID, gl::QueryID>(const ParamValue &value)
+{
+    return value.QueryIDVal;
+}
+
+template <>
+inline const gl::QueryID *GetParamVal<ParamType::TQueryIDConstPointer, const gl::QueryID *>(
+    const ParamValue &value)
+{
+    return value.QueryIDConstPointerVal;
+}
+
+template <>
+inline gl::QueryID *GetParamVal<ParamType::TQueryIDPointer, gl::QueryID *>(const ParamValue &value)
+{
+    return value.QueryIDPointerVal;
+}
+
+template <>
+inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value)
+{
+    return value.QueryTypeVal;
+}
+
+template <>
+inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>(
+    const ParamValue &value)
+{
+    return value.RenderbufferIDVal;
+}
+
+template <>
+inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer,
+                                             const gl::RenderbufferID *>(const ParamValue &value)
+{
+    return value.RenderbufferIDConstPointerVal;
+}
+
+template <>
+inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>(
+    const ParamValue &value)
+{
+    return value.RenderbufferIDPointerVal;
+}
+
+template <>
+inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value)
+{
+    return value.SamplerIDVal;
+}
+
+template <>
+inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>(
+    const ParamValue &value)
+{
+    return value.SamplerIDConstPointerVal;
+}
+
+template <>
+inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>(
+    const ParamValue &value)
+{
+    return value.SamplerIDPointerVal;
+}
+
+template <>
+inline gl::SemaphoreID GetParamVal<ParamType::TSemaphoreID, gl::SemaphoreID>(
+    const ParamValue &value)
+{
+    return value.SemaphoreIDVal;
+}
+
+template <>
+inline const gl::SemaphoreID *
+GetParamVal<ParamType::TSemaphoreIDConstPointer, const gl::SemaphoreID *>(const ParamValue &value)
+{
+    return value.SemaphoreIDConstPointerVal;
+}
+
+template <>
+inline gl::SemaphoreID *GetParamVal<ParamType::TSemaphoreIDPointer, gl::SemaphoreID *>(
+    const ParamValue &value)
+{
+    return value.SemaphoreIDPointerVal;
+}
+
+template <>
+inline gl::ShaderProgramID GetParamVal<ParamType::TShaderProgramID, gl::ShaderProgramID>(
+    const ParamValue &value)
+{
+    return value.ShaderProgramIDVal;
+}
+
+template <>
+inline const gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDConstPointer,
+                                              const gl::ShaderProgramID *>(const ParamValue &value)
+{
+    return value.ShaderProgramIDConstPointerVal;
+}
+
+template <>
+inline gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDPointer, gl::ShaderProgramID *>(
+    const ParamValue &value)
+{
+    return value.ShaderProgramIDPointerVal;
+}
+
+template <>
+inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value)
+{
+    return value.ShaderTypeVal;
+}
+
+template <>
+inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>(
+    const ParamValue &value)
+{
+    return value.ShadingModelVal;
+}
+
+template <>
+inline gl::TextureEnvParameter
+GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value)
+{
+    return value.TextureEnvParameterVal;
+}
+
+template <>
+inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>(
+    const ParamValue &value)
+{
+    return value.TextureEnvTargetVal;
+}
+
+template <>
+inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value)
+{
+    return value.TextureIDVal;
+}
+
+template <>
+inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>(
+    const ParamValue &value)
+{
+    return value.TextureIDConstPointerVal;
+}
+
+template <>
+inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>(
+    const ParamValue &value)
+{
+    return value.TextureIDPointerVal;
+}
+
+template <>
+inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>(
+    const ParamValue &value)
+{
+    return value.TextureTargetVal;
+}
+
+template <>
+inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>(
+    const ParamValue &value)
+{
+    return value.TextureTypeVal;
+}
+
+template <>
+inline gl::TransformFeedbackID
+GetParamVal<ParamType::TTransformFeedbackID, gl::TransformFeedbackID>(const ParamValue &value)
+{
+    return value.TransformFeedbackIDVal;
+}
+
+template <>
+inline const gl::TransformFeedbackID *
+GetParamVal<ParamType::TTransformFeedbackIDConstPointer, const gl::TransformFeedbackID *>(
+    const ParamValue &value)
+{
+    return value.TransformFeedbackIDConstPointerVal;
+}
+
+template <>
+inline gl::TransformFeedbackID *GetParamVal<ParamType::TTransformFeedbackIDPointer,
+                                            gl::TransformFeedbackID *>(const ParamValue &value)
+{
+    return value.TransformFeedbackIDPointerVal;
+}
+
+template <>
+inline gl::UniformBlockIndex GetParamVal<ParamType::TUniformBlockIndex, gl::UniformBlockIndex>(
+    const ParamValue &value)
+{
+    return value.UniformBlockIndexVal;
+}
+
+template <>
+inline gl::UniformLocation GetParamVal<ParamType::TUniformLocation, gl::UniformLocation>(
+    const ParamValue &value)
+{
+    return value.UniformLocationVal;
+}
+
+template <>
+inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>(
+    const ParamValue &value)
+{
+    return value.VertexArrayIDVal;
+}
+
+template <>
+inline const gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDConstPointer,
+                                            const gl::VertexArrayID *>(const ParamValue &value)
+{
+    return value.VertexArrayIDConstPointerVal;
+}
+
+template <>
+inline gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDPointer, gl::VertexArrayID *>(
+    const ParamValue &value)
+{
+    return value.VertexArrayIDPointerVal;
+}
+
+template <>
+inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>(
+    const ParamValue &value)
+{
+    return value.VertexAttribTypeVal;
+}
+
+template <>
+inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value)
+{
+    return value.voidConstPointerVal;
+}
+
+template <>
+inline const void *const *GetParamVal<ParamType::TvoidConstPointerPointer, const void *const *>(
+    const ParamValue &value)
+{
+    return value.voidConstPointerPointerVal;
+}
+
+template <>
+inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value)
+{
+    return value.voidPointerVal;
+}
+
+template <>
+inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value)
+{
+    return value.voidPointerPointerVal;
+}
+
+template <ParamType PType, typename T>
+T GetParamVal(const ParamValue &value)
+{
+    UNREACHABLE();
+    return T();
+}
+
+template <typename T>
+T AccessParamValue(ParamType paramType, const ParamValue &value)
+{
+    switch (paramType)
+    {
+        case ParamType::TAlphaTestFunc:
+            return GetParamVal<ParamType::TAlphaTestFunc, T>(value);
+        case ParamType::TBufferBinding:
+            return GetParamVal<ParamType::TBufferBinding, T>(value);
+        case ParamType::TBufferID:
+            return GetParamVal<ParamType::TBufferID, T>(value);
+        case ParamType::TBufferIDConstPointer:
+            return GetParamVal<ParamType::TBufferIDConstPointer, T>(value);
+        case ParamType::TBufferIDPointer:
+            return GetParamVal<ParamType::TBufferIDPointer, T>(value);
+        case ParamType::TBufferUsage:
+            return GetParamVal<ParamType::TBufferUsage, T>(value);
+        case ParamType::TClientVertexArrayType:
+            return GetParamVal<ParamType::TClientVertexArrayType, T>(value);
+        case ParamType::TCullFaceMode:
+            return GetParamVal<ParamType::TCullFaceMode, T>(value);
+        case ParamType::TDrawElementsType:
+            return GetParamVal<ParamType::TDrawElementsType, T>(value);
+        case ParamType::TFenceNVID:
+            return GetParamVal<ParamType::TFenceNVID, T>(value);
+        case ParamType::TFenceNVIDConstPointer:
+            return GetParamVal<ParamType::TFenceNVIDConstPointer, T>(value);
+        case ParamType::TFenceNVIDPointer:
+            return GetParamVal<ParamType::TFenceNVIDPointer, T>(value);
+        case ParamType::TFramebufferID:
+            return GetParamVal<ParamType::TFramebufferID, T>(value);
+        case ParamType::TFramebufferIDConstPointer:
+            return GetParamVal<ParamType::TFramebufferIDConstPointer, T>(value);
+        case ParamType::TFramebufferIDPointer:
+            return GetParamVal<ParamType::TFramebufferIDPointer, T>(value);
+        case ParamType::TGLDEBUGPROC:
+            return GetParamVal<ParamType::TGLDEBUGPROC, T>(value);
+        case ParamType::TGLDEBUGPROCKHR:
+            return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value);
+        case ParamType::TGLbitfield:
+            return GetParamVal<ParamType::TGLbitfield, T>(value);
+        case ParamType::TGLboolean:
+            return GetParamVal<ParamType::TGLboolean, T>(value);
+        case ParamType::TGLbooleanConstPointer:
+            return GetParamVal<ParamType::TGLbooleanConstPointer, T>(value);
+        case ParamType::TGLbooleanPointer:
+            return GetParamVal<ParamType::TGLbooleanPointer, T>(value);
+        case ParamType::TGLbyte:
+            return GetParamVal<ParamType::TGLbyte, T>(value);
+        case ParamType::TGLbyteConstPointer:
+            return GetParamVal<ParamType::TGLbyteConstPointer, T>(value);
+        case ParamType::TGLcharConstPointer:
+            return GetParamVal<ParamType::TGLcharConstPointer, T>(value);
+        case ParamType::TGLcharConstPointerPointer:
+            return GetParamVal<ParamType::TGLcharConstPointerPointer, T>(value);
+        case ParamType::TGLcharPointer:
+            return GetParamVal<ParamType::TGLcharPointer, T>(value);
+        case ParamType::TGLclampx:
+            return GetParamVal<ParamType::TGLclampx, T>(value);
+        case ParamType::TGLdouble:
+            return GetParamVal<ParamType::TGLdouble, T>(value);
+        case ParamType::TGLdoubleConstPointer:
+            return GetParamVal<ParamType::TGLdoubleConstPointer, T>(value);
+        case ParamType::TGLdoublePointer:
+            return GetParamVal<ParamType::TGLdoublePointer, T>(value);
+        case ParamType::TGLeglClientBufferEXT:
+            return GetParamVal<ParamType::TGLeglClientBufferEXT, T>(value);
+        case ParamType::TGLeglImageOES:
+            return GetParamVal<ParamType::TGLeglImageOES, T>(value);
+        case ParamType::TGLenum:
+            return GetParamVal<ParamType::TGLenum, T>(value);
+        case ParamType::TGLenumConstPointer:
+            return GetParamVal<ParamType::TGLenumConstPointer, T>(value);
+        case ParamType::TGLenumPointer:
+            return GetParamVal<ParamType::TGLenumPointer, T>(value);
+        case ParamType::TGLfixed:
+            return GetParamVal<ParamType::TGLfixed, T>(value);
+        case ParamType::TGLfixedConstPointer:
+            return GetParamVal<ParamType::TGLfixedConstPointer, T>(value);
+        case ParamType::TGLfixedPointer:
+            return GetParamVal<ParamType::TGLfixedPointer, T>(value);
+        case ParamType::TGLfloat:
+            return GetParamVal<ParamType::TGLfloat, T>(value);
+        case ParamType::TGLfloatConstPointer:
+            return GetParamVal<ParamType::TGLfloatConstPointer, T>(value);
+        case ParamType::TGLfloatPointer:
+            return GetParamVal<ParamType::TGLfloatPointer, T>(value);
+        case ParamType::TGLint:
+            return GetParamVal<ParamType::TGLint, T>(value);
+        case ParamType::TGLint64Pointer:
+            return GetParamVal<ParamType::TGLint64Pointer, T>(value);
+        case ParamType::TGLintConstPointer:
+            return GetParamVal<ParamType::TGLintConstPointer, T>(value);
+        case ParamType::TGLintPointer:
+            return GetParamVal<ParamType::TGLintPointer, T>(value);
+        case ParamType::TGLintptr:
+            return GetParamVal<ParamType::TGLintptr, T>(value);
+        case ParamType::TGLintptrConstPointer:
+            return GetParamVal<ParamType::TGLintptrConstPointer, T>(value);
+        case ParamType::TGLshort:
+            return GetParamVal<ParamType::TGLshort, T>(value);
+        case ParamType::TGLshortConstPointer:
+            return GetParamVal<ParamType::TGLshortConstPointer, T>(value);
+        case ParamType::TGLsizei:
+            return GetParamVal<ParamType::TGLsizei, T>(value);
+        case ParamType::TGLsizeiConstPointer:
+            return GetParamVal<ParamType::TGLsizeiConstPointer, T>(value);
+        case ParamType::TGLsizeiPointer:
+            return GetParamVal<ParamType::TGLsizeiPointer, T>(value);
+        case ParamType::TGLsizeiptr:
+            return GetParamVal<ParamType::TGLsizeiptr, T>(value);
+        case ParamType::TGLsizeiptrConstPointer:
+            return GetParamVal<ParamType::TGLsizeiptrConstPointer, T>(value);
+        case ParamType::TGLsync:
+            return GetParamVal<ParamType::TGLsync, T>(value);
+        case ParamType::TGLubyte:
+            return GetParamVal<ParamType::TGLubyte, T>(value);
+        case ParamType::TGLubyteConstPointer:
+            return GetParamVal<ParamType::TGLubyteConstPointer, T>(value);
+        case ParamType::TGLubytePointer:
+            return GetParamVal<ParamType::TGLubytePointer, T>(value);
+        case ParamType::TGLuint:
+            return GetParamVal<ParamType::TGLuint, T>(value);
+        case ParamType::TGLuint64:
+            return GetParamVal<ParamType::TGLuint64, T>(value);
+        case ParamType::TGLuint64ConstPointer:
+            return GetParamVal<ParamType::TGLuint64ConstPointer, T>(value);
+        case ParamType::TGLuint64Pointer:
+            return GetParamVal<ParamType::TGLuint64Pointer, T>(value);
+        case ParamType::TGLuintConstPointer:
+            return GetParamVal<ParamType::TGLuintConstPointer, T>(value);
+        case ParamType::TGLuintPointer:
+            return GetParamVal<ParamType::TGLuintPointer, T>(value);
+        case ParamType::TGLushort:
+            return GetParamVal<ParamType::TGLushort, T>(value);
+        case ParamType::TGLushortConstPointer:
+            return GetParamVal<ParamType::TGLushortConstPointer, T>(value);
+        case ParamType::TGLushortPointer:
+            return GetParamVal<ParamType::TGLushortPointer, T>(value);
+        case ParamType::TGLvoidConstPointer:
+            return GetParamVal<ParamType::TGLvoidConstPointer, T>(value);
+        case ParamType::TGLvoidConstPointerPointer:
+            return GetParamVal<ParamType::TGLvoidConstPointerPointer, T>(value);
+        case ParamType::TGraphicsResetStatus:
+            return GetParamVal<ParamType::TGraphicsResetStatus, T>(value);
+        case ParamType::THandleType:
+            return GetParamVal<ParamType::THandleType, T>(value);
+        case ParamType::TLightParameter:
+            return GetParamVal<ParamType::TLightParameter, T>(value);
+        case ParamType::TLogicalOperation:
+            return GetParamVal<ParamType::TLogicalOperation, T>(value);
+        case ParamType::TMaterialParameter:
+            return GetParamVal<ParamType::TMaterialParameter, T>(value);
+        case ParamType::TMatrixType:
+            return GetParamVal<ParamType::TMatrixType, T>(value);
+        case ParamType::TMemoryObjectID:
+            return GetParamVal<ParamType::TMemoryObjectID, T>(value);
+        case ParamType::TMemoryObjectIDConstPointer:
+            return GetParamVal<ParamType::TMemoryObjectIDConstPointer, T>(value);
+        case ParamType::TMemoryObjectIDPointer:
+            return GetParamVal<ParamType::TMemoryObjectIDPointer, T>(value);
+        case ParamType::TPointParameter:
+            return GetParamVal<ParamType::TPointParameter, T>(value);
+        case ParamType::TPrimitiveMode:
+            return GetParamVal<ParamType::TPrimitiveMode, T>(value);
+        case ParamType::TProgramPipelineID:
+            return GetParamVal<ParamType::TProgramPipelineID, T>(value);
+        case ParamType::TProgramPipelineIDConstPointer:
+            return GetParamVal<ParamType::TProgramPipelineIDConstPointer, T>(value);
+        case ParamType::TProgramPipelineIDPointer:
+            return GetParamVal<ParamType::TProgramPipelineIDPointer, T>(value);
+        case ParamType::TProvokingVertexConvention:
+            return GetParamVal<ParamType::TProvokingVertexConvention, T>(value);
+        case ParamType::TQueryID:
+            return GetParamVal<ParamType::TQueryID, T>(value);
+        case ParamType::TQueryIDConstPointer:
+            return GetParamVal<ParamType::TQueryIDConstPointer, T>(value);
+        case ParamType::TQueryIDPointer:
+            return GetParamVal<ParamType::TQueryIDPointer, T>(value);
+        case ParamType::TQueryType:
+            return GetParamVal<ParamType::TQueryType, T>(value);
+        case ParamType::TRenderbufferID:
+            return GetParamVal<ParamType::TRenderbufferID, T>(value);
+        case ParamType::TRenderbufferIDConstPointer:
+            return GetParamVal<ParamType::TRenderbufferIDConstPointer, T>(value);
+        case ParamType::TRenderbufferIDPointer:
+            return GetParamVal<ParamType::TRenderbufferIDPointer, T>(value);
+        case ParamType::TSamplerID:
+            return GetParamVal<ParamType::TSamplerID, T>(value);
+        case ParamType::TSamplerIDConstPointer:
+            return GetParamVal<ParamType::TSamplerIDConstPointer, T>(value);
+        case ParamType::TSamplerIDPointer:
+            return GetParamVal<ParamType::TSamplerIDPointer, T>(value);
+        case ParamType::TSemaphoreID:
+            return GetParamVal<ParamType::TSemaphoreID, T>(value);
+        case ParamType::TSemaphoreIDConstPointer:
+            return GetParamVal<ParamType::TSemaphoreIDConstPointer, T>(value);
+        case ParamType::TSemaphoreIDPointer:
+            return GetParamVal<ParamType::TSemaphoreIDPointer, T>(value);
+        case ParamType::TShaderProgramID:
+            return GetParamVal<ParamType::TShaderProgramID, T>(value);
+        case ParamType::TShaderProgramIDConstPointer:
+            return GetParamVal<ParamType::TShaderProgramIDConstPointer, T>(value);
+        case ParamType::TShaderProgramIDPointer:
+            return GetParamVal<ParamType::TShaderProgramIDPointer, T>(value);
+        case ParamType::TShaderType:
+            return GetParamVal<ParamType::TShaderType, T>(value);
+        case ParamType::TShadingModel:
+            return GetParamVal<ParamType::TShadingModel, T>(value);
+        case ParamType::TTextureEnvParameter:
+            return GetParamVal<ParamType::TTextureEnvParameter, T>(value);
+        case ParamType::TTextureEnvTarget:
+            return GetParamVal<ParamType::TTextureEnvTarget, T>(value);
+        case ParamType::TTextureID:
+            return GetParamVal<ParamType::TTextureID, T>(value);
+        case ParamType::TTextureIDConstPointer:
+            return GetParamVal<ParamType::TTextureIDConstPointer, T>(value);
+        case ParamType::TTextureIDPointer:
+            return GetParamVal<ParamType::TTextureIDPointer, T>(value);
+        case ParamType::TTextureTarget:
+            return GetParamVal<ParamType::TTextureTarget, T>(value);
+        case ParamType::TTextureType:
+            return GetParamVal<ParamType::TTextureType, T>(value);
+        case ParamType::TTransformFeedbackID:
+            return GetParamVal<ParamType::TTransformFeedbackID, T>(value);
+        case ParamType::TTransformFeedbackIDConstPointer:
+            return GetParamVal<ParamType::TTransformFeedbackIDConstPointer, T>(value);
+        case ParamType::TTransformFeedbackIDPointer:
+            return GetParamVal<ParamType::TTransformFeedbackIDPointer, T>(value);
+        case ParamType::TUniformBlockIndex:
+            return GetParamVal<ParamType::TUniformBlockIndex, T>(value);
+        case ParamType::TUniformLocation:
+            return GetParamVal<ParamType::TUniformLocation, T>(value);
+        case ParamType::TVertexArrayID:
+            return GetParamVal<ParamType::TVertexArrayID, T>(value);
+        case ParamType::TVertexArrayIDConstPointer:
+            return GetParamVal<ParamType::TVertexArrayIDConstPointer, T>(value);
+        case ParamType::TVertexArrayIDPointer:
+            return GetParamVal<ParamType::TVertexArrayIDPointer, T>(value);
+        case ParamType::TVertexAttribType:
+            return GetParamVal<ParamType::TVertexAttribType, T>(value);
+        case ParamType::TvoidConstPointer:
+            return GetParamVal<ParamType::TvoidConstPointer, T>(value);
+        case ParamType::TvoidConstPointerPointer:
+            return GetParamVal<ParamType::TvoidConstPointerPointer, T>(value);
+        case ParamType::TvoidPointer:
+            return GetParamVal<ParamType::TvoidPointer, T>(value);
+        case ParamType::TvoidPointerPointer:
+            return GetParamVal<ParamType::TvoidPointerPointer, T>(value);
+    }
+}
+
+template <ParamType PType, typename T>
+void SetParamVal(T valueIn, ParamValue *valueOut);
+
+template <>
+inline void SetParamVal<ParamType::TAlphaTestFunc>(gl::AlphaTestFunc valueIn, ParamValue *valueOut)
+{
+    valueOut->AlphaTestFuncVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TBufferBinding>(gl::BufferBinding valueIn, ParamValue *valueOut)
+{
+    valueOut->BufferBindingVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TBufferID>(gl::BufferID valueIn, ParamValue *valueOut)
+{
+    valueOut->BufferIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TBufferIDConstPointer>(const gl::BufferID *valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->BufferIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TBufferIDPointer>(gl::BufferID *valueIn, ParamValue *valueOut)
+{
+    valueOut->BufferIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TBufferUsage>(gl::BufferUsage valueIn, ParamValue *valueOut)
+{
+    valueOut->BufferUsageVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TClientVertexArrayType>(gl::ClientVertexArrayType valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->ClientVertexArrayTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TCullFaceMode>(gl::CullFaceMode valueIn, ParamValue *valueOut)
+{
+    valueOut->CullFaceModeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TDrawElementsType>(gl::DrawElementsType valueIn,
+                                                      ParamValue *valueOut)
+{
+    valueOut->DrawElementsTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TFenceNVID>(gl::FenceNVID valueIn, ParamValue *valueOut)
+{
+    valueOut->FenceNVIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TFenceNVIDConstPointer>(const gl::FenceNVID *valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->FenceNVIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TFenceNVIDPointer>(gl::FenceNVID *valueIn, ParamValue *valueOut)
+{
+    valueOut->FenceNVIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TFramebufferID>(gl::FramebufferID valueIn, ParamValue *valueOut)
+{
+    valueOut->FramebufferIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TFramebufferIDConstPointer>(const gl::FramebufferID *valueIn,
+                                                               ParamValue *valueOut)
+{
+    valueOut->FramebufferIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TFramebufferIDPointer>(gl::FramebufferID *valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->FramebufferIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLDEBUGPROC>(GLDEBUGPROC valueIn, ParamValue *valueOut)
+{
+    valueOut->GLDEBUGPROCVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, ParamValue *valueOut)
+{
+    valueOut->GLDEBUGPROCKHRVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut)
+{
+    valueOut->GLbitfieldVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLboolean>(GLboolean valueIn, ParamValue *valueOut)
+{
+    valueOut->GLbooleanVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLbooleanConstPointer>(const GLboolean *valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->GLbooleanConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLbooleanPointer>(GLboolean *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLbooleanPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLbyte>(GLbyte valueIn, ParamValue *valueOut)
+{
+    valueOut->GLbyteVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLbyteConstPointer>(const GLbyte *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLbyteConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLcharConstPointer>(const GLchar *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLcharConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLcharConstPointerPointer>(const GLchar *const *valueIn,
+                                                               ParamValue *valueOut)
+{
+    valueOut->GLcharConstPointerPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLcharPointer>(GLchar *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLcharPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLclampx>(GLclampx valueIn, ParamValue *valueOut)
+{
+    valueOut->GLclampxVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLdouble>(GLdouble valueIn, ParamValue *valueOut)
+{
+    valueOut->GLdoubleVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLdoubleConstPointer>(const GLdouble *valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->GLdoubleConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLdoublePointer>(GLdouble *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLdoublePointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLeglClientBufferEXT>(GLeglClientBufferEXT valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->GLeglClientBufferEXTVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLeglImageOES>(GLeglImageOES valueIn, ParamValue *valueOut)
+{
+    valueOut->GLeglImageOESVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLenum>(GLenum valueIn, ParamValue *valueOut)
+{
+    valueOut->GLenumVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLenumConstPointer>(const GLenum *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLenumConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLenumPointer>(GLenum *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLenumPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLfixed>(GLfixed valueIn, ParamValue *valueOut)
+{
+    valueOut->GLfixedVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLfixedConstPointer>(const GLfixed *valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->GLfixedConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLfixedPointer>(GLfixed *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLfixedPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLfloat>(GLfloat valueIn, ParamValue *valueOut)
+{
+    valueOut->GLfloatVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLfloatConstPointer>(const GLfloat *valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->GLfloatConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLfloatPointer>(GLfloat *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLfloatPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLint>(GLint valueIn, ParamValue *valueOut)
+{
+    valueOut->GLintVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLint64Pointer>(GLint64 *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLint64PointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLintConstPointer>(const GLint *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLintConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLintPointer>(GLint *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLintPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLintptr>(GLintptr valueIn, ParamValue *valueOut)
+{
+    valueOut->GLintptrVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLintptrConstPointer>(const GLintptr *valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->GLintptrConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLshort>(GLshort valueIn, ParamValue *valueOut)
+{
+    valueOut->GLshortVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLshortConstPointer>(const GLshort *valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->GLshortConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLsizei>(GLsizei valueIn, ParamValue *valueOut)
+{
+    valueOut->GLsizeiVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLsizeiConstPointer>(const GLsizei *valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->GLsizeiConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLsizeiPointer>(GLsizei *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLsizeiPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLsizeiptr>(GLsizeiptr valueIn, ParamValue *valueOut)
+{
+    valueOut->GLsizeiptrVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLsizeiptrConstPointer>(const GLsizeiptr *valueIn,
+                                                            ParamValue *valueOut)
+{
+    valueOut->GLsizeiptrConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLsync>(GLsync valueIn, ParamValue *valueOut)
+{
+    valueOut->GLsyncVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLubyte>(GLubyte valueIn, ParamValue *valueOut)
+{
+    valueOut->GLubyteVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLubyteConstPointer>(const GLubyte *valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->GLubyteConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLubytePointer>(GLubyte *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLubytePointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLuint>(GLuint valueIn, ParamValue *valueOut)
+{
+    valueOut->GLuintVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLuint64>(GLuint64 valueIn, ParamValue *valueOut)
+{
+    valueOut->GLuint64Val = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLuint64ConstPointer>(const GLuint64 *valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->GLuint64ConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLuint64Pointer>(GLuint64 *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLuint64PointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLuintConstPointer>(const GLuint *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLuintConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLuintPointer>(GLuint *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLuintPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLushort>(GLushort valueIn, ParamValue *valueOut)
+{
+    valueOut->GLushortVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLushortConstPointer>(const GLushort *valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->GLushortConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLushortPointer>(GLushort *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLushortPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLvoidConstPointer>(const GLvoid *valueIn, ParamValue *valueOut)
+{
+    valueOut->GLvoidConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGLvoidConstPointerPointer>(const GLvoid *const *valueIn,
+                                                               ParamValue *valueOut)
+{
+    valueOut->GLvoidConstPointerPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TGraphicsResetStatus>(gl::GraphicsResetStatus valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->GraphicsResetStatusVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::THandleType>(gl::HandleType valueIn, ParamValue *valueOut)
+{
+    valueOut->HandleTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TLightParameter>(gl::LightParameter valueIn,
+                                                    ParamValue *valueOut)
+{
+    valueOut->LightParameterVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TLogicalOperation>(gl::LogicalOperation valueIn,
+                                                      ParamValue *valueOut)
+{
+    valueOut->LogicalOperationVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TMaterialParameter>(gl::MaterialParameter valueIn,
+                                                       ParamValue *valueOut)
+{
+    valueOut->MaterialParameterVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TMatrixType>(gl::MatrixType valueIn, ParamValue *valueOut)
+{
+    valueOut->MatrixTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TMemoryObjectID>(gl::MemoryObjectID valueIn,
+                                                    ParamValue *valueOut)
+{
+    valueOut->MemoryObjectIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TMemoryObjectIDConstPointer>(const gl::MemoryObjectID *valueIn,
+                                                                ParamValue *valueOut)
+{
+    valueOut->MemoryObjectIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TMemoryObjectIDPointer>(gl::MemoryObjectID *valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->MemoryObjectIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn,
+                                                    ParamValue *valueOut)
+{
+    valueOut->PointParameterVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TPrimitiveMode>(gl::PrimitiveMode valueIn, ParamValue *valueOut)
+{
+    valueOut->PrimitiveModeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TProgramPipelineID>(gl::ProgramPipelineID valueIn,
+                                                       ParamValue *valueOut)
+{
+    valueOut->ProgramPipelineIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TProgramPipelineIDConstPointer>(
+    const gl::ProgramPipelineID *valueIn,
+    ParamValue *valueOut)
+{
+    valueOut->ProgramPipelineIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TProgramPipelineIDPointer>(gl::ProgramPipelineID *valueIn,
+                                                              ParamValue *valueOut)
+{
+    valueOut->ProgramPipelineIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TProvokingVertexConvention>(
+    gl::ProvokingVertexConvention valueIn,
+    ParamValue *valueOut)
+{
+    valueOut->ProvokingVertexConventionVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TQueryID>(gl::QueryID valueIn, ParamValue *valueOut)
+{
+    valueOut->QueryIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TQueryIDConstPointer>(const gl::QueryID *valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->QueryIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TQueryIDPointer>(gl::QueryID *valueIn, ParamValue *valueOut)
+{
+    valueOut->QueryIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TQueryType>(gl::QueryType valueIn, ParamValue *valueOut)
+{
+    valueOut->QueryTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TRenderbufferID>(gl::RenderbufferID valueIn,
+                                                    ParamValue *valueOut)
+{
+    valueOut->RenderbufferIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TRenderbufferIDConstPointer>(const gl::RenderbufferID *valueIn,
+                                                                ParamValue *valueOut)
+{
+    valueOut->RenderbufferIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TRenderbufferIDPointer>(gl::RenderbufferID *valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->RenderbufferIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TSamplerID>(gl::SamplerID valueIn, ParamValue *valueOut)
+{
+    valueOut->SamplerIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TSamplerIDConstPointer>(const gl::SamplerID *valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->SamplerIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TSamplerIDPointer>(gl::SamplerID *valueIn, ParamValue *valueOut)
+{
+    valueOut->SamplerIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TSemaphoreID>(gl::SemaphoreID valueIn, ParamValue *valueOut)
+{
+    valueOut->SemaphoreIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TSemaphoreIDConstPointer>(const gl::SemaphoreID *valueIn,
+                                                             ParamValue *valueOut)
+{
+    valueOut->SemaphoreIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TSemaphoreIDPointer>(gl::SemaphoreID *valueIn,
+                                                        ParamValue *valueOut)
+{
+    valueOut->SemaphoreIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TShaderProgramID>(gl::ShaderProgramID valueIn,
+                                                     ParamValue *valueOut)
+{
+    valueOut->ShaderProgramIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TShaderProgramIDConstPointer>(const gl::ShaderProgramID *valueIn,
+                                                                 ParamValue *valueOut)
+{
+    valueOut->ShaderProgramIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TShaderProgramIDPointer>(gl::ShaderProgramID *valueIn,
+                                                            ParamValue *valueOut)
+{
+    valueOut->ShaderProgramIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TShaderType>(gl::ShaderType valueIn, ParamValue *valueOut)
+{
+    valueOut->ShaderTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TShadingModel>(gl::ShadingModel valueIn, ParamValue *valueOut)
+{
+    valueOut->ShadingModelVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTextureEnvParameter>(gl::TextureEnvParameter valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->TextureEnvParameterVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTextureEnvTarget>(gl::TextureEnvTarget valueIn,
+                                                      ParamValue *valueOut)
+{
+    valueOut->TextureEnvTargetVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTextureID>(gl::TextureID valueIn, ParamValue *valueOut)
+{
+    valueOut->TextureIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTextureIDConstPointer>(const gl::TextureID *valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->TextureIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTextureIDPointer>(gl::TextureID *valueIn, ParamValue *valueOut)
+{
+    valueOut->TextureIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTextureTarget>(gl::TextureTarget valueIn, ParamValue *valueOut)
+{
+    valueOut->TextureTargetVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTextureType>(gl::TextureType valueIn, ParamValue *valueOut)
+{
+    valueOut->TextureTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTransformFeedbackID>(gl::TransformFeedbackID valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->TransformFeedbackIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(
+    const gl::TransformFeedbackID *valueIn,
+    ParamValue *valueOut)
+{
+    valueOut->TransformFeedbackIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TTransformFeedbackIDPointer>(gl::TransformFeedbackID *valueIn,
+                                                                ParamValue *valueOut)
+{
+    valueOut->TransformFeedbackIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TUniformBlockIndex>(gl::UniformBlockIndex valueIn,
+                                                       ParamValue *valueOut)
+{
+    valueOut->UniformBlockIndexVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TUniformLocation>(gl::UniformLocation valueIn,
+                                                     ParamValue *valueOut)
+{
+    valueOut->UniformLocationVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut)
+{
+    valueOut->VertexArrayIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TVertexArrayIDConstPointer>(const gl::VertexArrayID *valueIn,
+                                                               ParamValue *valueOut)
+{
+    valueOut->VertexArrayIDConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TVertexArrayIDPointer>(gl::VertexArrayID *valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->VertexArrayIDPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TVertexAttribType>(gl::VertexAttribType valueIn,
+                                                      ParamValue *valueOut)
+{
+    valueOut->VertexAttribTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TvoidConstPointer>(const void *valueIn, ParamValue *valueOut)
+{
+    valueOut->voidConstPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TvoidConstPointerPointer>(const void *const *valueIn,
+                                                             ParamValue *valueOut)
+{
+    valueOut->voidConstPointerPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TvoidPointer>(void *valueIn, ParamValue *valueOut)
+{
+    valueOut->voidPointerVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TvoidPointerPointer>(void **valueIn, ParamValue *valueOut)
+{
+    valueOut->voidPointerPointerVal = valueIn;
+}
+
+template <ParamType PType, typename T>
+void SetParamVal(T valueIn, ParamValue *valueOut)
+{
+    UNREACHABLE();
+}
+
+template <typename T>
+void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
+{
+    switch (paramType)
+    {
+        case ParamType::TAlphaTestFunc:
+            SetParamVal<ParamType::TAlphaTestFunc>(valueIn, valueOut);
+            break;
+        case ParamType::TBufferBinding:
+            SetParamVal<ParamType::TBufferBinding>(valueIn, valueOut);
+            break;
+        case ParamType::TBufferID:
+            SetParamVal<ParamType::TBufferID>(valueIn, valueOut);
+            break;
+        case ParamType::TBufferIDConstPointer:
+            SetParamVal<ParamType::TBufferIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TBufferIDPointer:
+            SetParamVal<ParamType::TBufferIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TBufferUsage:
+            SetParamVal<ParamType::TBufferUsage>(valueIn, valueOut);
+            break;
+        case ParamType::TClientVertexArrayType:
+            SetParamVal<ParamType::TClientVertexArrayType>(valueIn, valueOut);
+            break;
+        case ParamType::TCullFaceMode:
+            SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut);
+            break;
+        case ParamType::TDrawElementsType:
+            SetParamVal<ParamType::TDrawElementsType>(valueIn, valueOut);
+            break;
+        case ParamType::TFenceNVID:
+            SetParamVal<ParamType::TFenceNVID>(valueIn, valueOut);
+            break;
+        case ParamType::TFenceNVIDConstPointer:
+            SetParamVal<ParamType::TFenceNVIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TFenceNVIDPointer:
+            SetParamVal<ParamType::TFenceNVIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TFramebufferID:
+            SetParamVal<ParamType::TFramebufferID>(valueIn, valueOut);
+            break;
+        case ParamType::TFramebufferIDConstPointer:
+            SetParamVal<ParamType::TFramebufferIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TFramebufferIDPointer:
+            SetParamVal<ParamType::TFramebufferIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLDEBUGPROC:
+            SetParamVal<ParamType::TGLDEBUGPROC>(valueIn, valueOut);
+            break;
+        case ParamType::TGLDEBUGPROCKHR:
+            SetParamVal<ParamType::TGLDEBUGPROCKHR>(valueIn, valueOut);
+            break;
+        case ParamType::TGLbitfield:
+            SetParamVal<ParamType::TGLbitfield>(valueIn, valueOut);
+            break;
+        case ParamType::TGLboolean:
+            SetParamVal<ParamType::TGLboolean>(valueIn, valueOut);
+            break;
+        case ParamType::TGLbooleanConstPointer:
+            SetParamVal<ParamType::TGLbooleanConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLbooleanPointer:
+            SetParamVal<ParamType::TGLbooleanPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLbyte:
+            SetParamVal<ParamType::TGLbyte>(valueIn, valueOut);
+            break;
+        case ParamType::TGLbyteConstPointer:
+            SetParamVal<ParamType::TGLbyteConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLcharConstPointer:
+            SetParamVal<ParamType::TGLcharConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLcharConstPointerPointer:
+            SetParamVal<ParamType::TGLcharConstPointerPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLcharPointer:
+            SetParamVal<ParamType::TGLcharPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLclampx:
+            SetParamVal<ParamType::TGLclampx>(valueIn, valueOut);
+            break;
+        case ParamType::TGLdouble:
+            SetParamVal<ParamType::TGLdouble>(valueIn, valueOut);
+            break;
+        case ParamType::TGLdoubleConstPointer:
+            SetParamVal<ParamType::TGLdoubleConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLdoublePointer:
+            SetParamVal<ParamType::TGLdoublePointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLeglClientBufferEXT:
+            SetParamVal<ParamType::TGLeglClientBufferEXT>(valueIn, valueOut);
+            break;
+        case ParamType::TGLeglImageOES:
+            SetParamVal<ParamType::TGLeglImageOES>(valueIn, valueOut);
+            break;
+        case ParamType::TGLenum:
+            SetParamVal<ParamType::TGLenum>(valueIn, valueOut);
+            break;
+        case ParamType::TGLenumConstPointer:
+            SetParamVal<ParamType::TGLenumConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLenumPointer:
+            SetParamVal<ParamType::TGLenumPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLfixed:
+            SetParamVal<ParamType::TGLfixed>(valueIn, valueOut);
+            break;
+        case ParamType::TGLfixedConstPointer:
+            SetParamVal<ParamType::TGLfixedConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLfixedPointer:
+            SetParamVal<ParamType::TGLfixedPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLfloat:
+            SetParamVal<ParamType::TGLfloat>(valueIn, valueOut);
+            break;
+        case ParamType::TGLfloatConstPointer:
+            SetParamVal<ParamType::TGLfloatConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLfloatPointer:
+            SetParamVal<ParamType::TGLfloatPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLint:
+            SetParamVal<ParamType::TGLint>(valueIn, valueOut);
+            break;
+        case ParamType::TGLint64Pointer:
+            SetParamVal<ParamType::TGLint64Pointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLintConstPointer:
+            SetParamVal<ParamType::TGLintConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLintPointer:
+            SetParamVal<ParamType::TGLintPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLintptr:
+            SetParamVal<ParamType::TGLintptr>(valueIn, valueOut);
+            break;
+        case ParamType::TGLintptrConstPointer:
+            SetParamVal<ParamType::TGLintptrConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLshort:
+            SetParamVal<ParamType::TGLshort>(valueIn, valueOut);
+            break;
+        case ParamType::TGLshortConstPointer:
+            SetParamVal<ParamType::TGLshortConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLsizei:
+            SetParamVal<ParamType::TGLsizei>(valueIn, valueOut);
+            break;
+        case ParamType::TGLsizeiConstPointer:
+            SetParamVal<ParamType::TGLsizeiConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLsizeiPointer:
+            SetParamVal<ParamType::TGLsizeiPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLsizeiptr:
+            SetParamVal<ParamType::TGLsizeiptr>(valueIn, valueOut);
+            break;
+        case ParamType::TGLsizeiptrConstPointer:
+            SetParamVal<ParamType::TGLsizeiptrConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLsync:
+            SetParamVal<ParamType::TGLsync>(valueIn, valueOut);
+            break;
+        case ParamType::TGLubyte:
+            SetParamVal<ParamType::TGLubyte>(valueIn, valueOut);
+            break;
+        case ParamType::TGLubyteConstPointer:
+            SetParamVal<ParamType::TGLubyteConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLubytePointer:
+            SetParamVal<ParamType::TGLubytePointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLuint:
+            SetParamVal<ParamType::TGLuint>(valueIn, valueOut);
+            break;
+        case ParamType::TGLuint64:
+            SetParamVal<ParamType::TGLuint64>(valueIn, valueOut);
+            break;
+        case ParamType::TGLuint64ConstPointer:
+            SetParamVal<ParamType::TGLuint64ConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLuint64Pointer:
+            SetParamVal<ParamType::TGLuint64Pointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLuintConstPointer:
+            SetParamVal<ParamType::TGLuintConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLuintPointer:
+            SetParamVal<ParamType::TGLuintPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLushort:
+            SetParamVal<ParamType::TGLushort>(valueIn, valueOut);
+            break;
+        case ParamType::TGLushortConstPointer:
+            SetParamVal<ParamType::TGLushortConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLushortPointer:
+            SetParamVal<ParamType::TGLushortPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLvoidConstPointer:
+            SetParamVal<ParamType::TGLvoidConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGLvoidConstPointerPointer:
+            SetParamVal<ParamType::TGLvoidConstPointerPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TGraphicsResetStatus:
+            SetParamVal<ParamType::TGraphicsResetStatus>(valueIn, valueOut);
+            break;
+        case ParamType::THandleType:
+            SetParamVal<ParamType::THandleType>(valueIn, valueOut);
+            break;
+        case ParamType::TLightParameter:
+            SetParamVal<ParamType::TLightParameter>(valueIn, valueOut);
+            break;
+        case ParamType::TLogicalOperation:
+            SetParamVal<ParamType::TLogicalOperation>(valueIn, valueOut);
+            break;
+        case ParamType::TMaterialParameter:
+            SetParamVal<ParamType::TMaterialParameter>(valueIn, valueOut);
+            break;
+        case ParamType::TMatrixType:
+            SetParamVal<ParamType::TMatrixType>(valueIn, valueOut);
+            break;
+        case ParamType::TMemoryObjectID:
+            SetParamVal<ParamType::TMemoryObjectID>(valueIn, valueOut);
+            break;
+        case ParamType::TMemoryObjectIDConstPointer:
+            SetParamVal<ParamType::TMemoryObjectIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TMemoryObjectIDPointer:
+            SetParamVal<ParamType::TMemoryObjectIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TPointParameter:
+            SetParamVal<ParamType::TPointParameter>(valueIn, valueOut);
+            break;
+        case ParamType::TPrimitiveMode:
+            SetParamVal<ParamType::TPrimitiveMode>(valueIn, valueOut);
+            break;
+        case ParamType::TProgramPipelineID:
+            SetParamVal<ParamType::TProgramPipelineID>(valueIn, valueOut);
+            break;
+        case ParamType::TProgramPipelineIDConstPointer:
+            SetParamVal<ParamType::TProgramPipelineIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TProgramPipelineIDPointer:
+            SetParamVal<ParamType::TProgramPipelineIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TProvokingVertexConvention:
+            SetParamVal<ParamType::TProvokingVertexConvention>(valueIn, valueOut);
+            break;
+        case ParamType::TQueryID:
+            SetParamVal<ParamType::TQueryID>(valueIn, valueOut);
+            break;
+        case ParamType::TQueryIDConstPointer:
+            SetParamVal<ParamType::TQueryIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TQueryIDPointer:
+            SetParamVal<ParamType::TQueryIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TQueryType:
+            SetParamVal<ParamType::TQueryType>(valueIn, valueOut);
+            break;
+        case ParamType::TRenderbufferID:
+            SetParamVal<ParamType::TRenderbufferID>(valueIn, valueOut);
+            break;
+        case ParamType::TRenderbufferIDConstPointer:
+            SetParamVal<ParamType::TRenderbufferIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TRenderbufferIDPointer:
+            SetParamVal<ParamType::TRenderbufferIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TSamplerID:
+            SetParamVal<ParamType::TSamplerID>(valueIn, valueOut);
+            break;
+        case ParamType::TSamplerIDConstPointer:
+            SetParamVal<ParamType::TSamplerIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TSamplerIDPointer:
+            SetParamVal<ParamType::TSamplerIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TSemaphoreID:
+            SetParamVal<ParamType::TSemaphoreID>(valueIn, valueOut);
+            break;
+        case ParamType::TSemaphoreIDConstPointer:
+            SetParamVal<ParamType::TSemaphoreIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TSemaphoreIDPointer:
+            SetParamVal<ParamType::TSemaphoreIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TShaderProgramID:
+            SetParamVal<ParamType::TShaderProgramID>(valueIn, valueOut);
+            break;
+        case ParamType::TShaderProgramIDConstPointer:
+            SetParamVal<ParamType::TShaderProgramIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TShaderProgramIDPointer:
+            SetParamVal<ParamType::TShaderProgramIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TShaderType:
+            SetParamVal<ParamType::TShaderType>(valueIn, valueOut);
+            break;
+        case ParamType::TShadingModel:
+            SetParamVal<ParamType::TShadingModel>(valueIn, valueOut);
+            break;
+        case ParamType::TTextureEnvParameter:
+            SetParamVal<ParamType::TTextureEnvParameter>(valueIn, valueOut);
+            break;
+        case ParamType::TTextureEnvTarget:
+            SetParamVal<ParamType::TTextureEnvTarget>(valueIn, valueOut);
+            break;
+        case ParamType::TTextureID:
+            SetParamVal<ParamType::TTextureID>(valueIn, valueOut);
+            break;
+        case ParamType::TTextureIDConstPointer:
+            SetParamVal<ParamType::TTextureIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TTextureIDPointer:
+            SetParamVal<ParamType::TTextureIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TTextureTarget:
+            SetParamVal<ParamType::TTextureTarget>(valueIn, valueOut);
+            break;
+        case ParamType::TTextureType:
+            SetParamVal<ParamType::TTextureType>(valueIn, valueOut);
+            break;
+        case ParamType::TTransformFeedbackID:
+            SetParamVal<ParamType::TTransformFeedbackID>(valueIn, valueOut);
+            break;
+        case ParamType::TTransformFeedbackIDConstPointer:
+            SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TTransformFeedbackIDPointer:
+            SetParamVal<ParamType::TTransformFeedbackIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TUniformBlockIndex:
+            SetParamVal<ParamType::TUniformBlockIndex>(valueIn, valueOut);
+            break;
+        case ParamType::TUniformLocation:
+            SetParamVal<ParamType::TUniformLocation>(valueIn, valueOut);
+            break;
+        case ParamType::TVertexArrayID:
+            SetParamVal<ParamType::TVertexArrayID>(valueIn, valueOut);
+            break;
+        case ParamType::TVertexArrayIDConstPointer:
+            SetParamVal<ParamType::TVertexArrayIDConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TVertexArrayIDPointer:
+            SetParamVal<ParamType::TVertexArrayIDPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TVertexAttribType:
+            SetParamVal<ParamType::TVertexAttribType>(valueIn, valueOut);
+            break;
+        case ParamType::TvoidConstPointer:
+            SetParamVal<ParamType::TvoidConstPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TvoidConstPointerPointer:
+            SetParamVal<ParamType::TvoidConstPointerPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TvoidPointer:
+            SetParamVal<ParamType::TvoidPointer>(valueIn, valueOut);
+            break;
+        case ParamType::TvoidPointerPointer:
+            SetParamVal<ParamType::TvoidPointerPointer>(valueIn, valueOut);
+            break;
+    }
+}
+
+struct CallCapture;
+struct ParamCapture;
+
+void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param);
+const char *ParamTypeToString(ParamType paramType);
+
+enum class ResourceIDType
+{
+    Buffer,
+    FenceNV,
+    Framebuffer,
+    MemoryObject,
+    ProgramPipeline,
+    Query,
+    Renderbuffer,
+    Sampler,
+    Semaphore,
+    ShaderProgram,
+    Texture,
+    TransformFeedback,
+    VertexArray,
+    EnumCount,
+    InvalidEnum = EnumCount
+};
+
+ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType);
+const char *GetResourceIDTypeName(ResourceIDType resourceIDType);
+}  // namespace angle
+
+#endif  // LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_mock.cpp b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_mock.cpp
new file mode 100644
index 0000000000..f136a3c17d
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_mock.cpp
@@ -0,0 +1,19 @@
+//
+// Copyright 2021 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.
+//
+// frame_capture_utils_mock.cpp:
+//   ANGLE frame capture util stub implementation.
+//
+
+#include "libANGLE/capture/frame_capture_utils.h"
+
+namespace angle
+{
+Result SerializeContextToString(const gl::Context *context, std::string *stringOut)
+{
+    *stringOut = "SerializationNotAvailable";
+    return angle::Result::Continue;
+}
+}  // namespace angle
diff --git a/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils.h b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils.h
new file mode 100644
index 0000000000..08e4f173f2
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils.h
@@ -0,0 +1,28 @@
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// gl_enum_utils.h:
+//   Utility functions for converting GLenums to string.
+
+#ifndef LIBANGLE_GL_ENUM_UTILS_H_
+#define LIBANGLE_GL_ENUM_UTILS_H_
+
+#include <ostream>
+#include <string>
+
+#include "libANGLE/capture/gl_enum_utils_autogen.h"
+
+namespace gl
+{
+const char *GLbooleanToString(unsigned int value);
+const char *GLenumToString(GLenumGroup enumGroup, unsigned int value);
+std::string GLbitfieldToString(GLenumGroup enumGroup, unsigned int value);
+void OutputGLenumString(std::ostream &out, GLenumGroup enumGroup, unsigned int value);
+void OutputGLbitfieldString(std::ostream &out, GLenumGroup enumGroup, unsigned int value);
+
+extern const char kUnknownGLenumString[];
+}  // namespace gl
+
+#endif  // LIBANGLE_GL_ENUM_UTILS_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils_autogen.h
new file mode 100644
index 0000000000..560fa54dec
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils_autogen.h
@@ -0,0 +1,218 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_gl_enum_utils.py using data from gl.xml and gl_angle_ext.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// gl_enum_utils_autogen.h:
+//   mapping of GLenum value to string.
+
+#ifndef LIBANGLE_GL_ENUM_UTILS_AUTOGEN_H_
+#define LIBANGLE_GL_ENUM_UTILS_AUTOGEN_H_
+
+namespace gl
+{
+enum class GLenumGroup
+{
+    AccumOp,
+    AlphaFunction,
+    AtomicCounterBufferPName,
+    AttribMask,
+    AttributeType,
+    BindTransformFeedbackTarget,
+    BlendEquationModeEXT,
+    BlendingFactor,
+    BlitFramebufferFilter,
+    Boolean,
+    Buffer,
+    BufferAccessARB,
+    BufferAccessMask,
+    BufferBitQCOM,
+    BufferStorageTarget,
+    BufferTargetARB,
+    BufferUsageARB,
+    CheckFramebufferStatusTarget,
+    ClearBufferMask,
+    ClientAttribMask,
+    ClipControlDepth,
+    ClipControlOrigin,
+    ClipPlaneName,
+    ColorBuffer,
+    ColorMaterialFace,
+    ColorMaterialParameter,
+    ColorPointerType,
+    ColorTableParameterPNameSGI,
+    ColorTableTarget,
+    ColorTableTargetSGI,
+    ContextFlagMask,
+    ContextProfileMask,
+    ConvolutionBorderModeEXT,
+    ConvolutionParameterEXT,
+    ConvolutionTarget,
+    ConvolutionTargetEXT,
+    CopyBufferSubDataTarget,
+    CullFaceMode,
+    DataType,
+    DebugSeverity,
+    DebugSource,
+    DebugType,
+    DefaultGroup,
+    DepthFunction,
+    DrawBufferMode,
+    DrawElementsType,
+    EnableCap,
+    ErrorCode,
+    ExternalHandleType,
+    FeedBackToken,
+    FeedbackType,
+    FfdMaskSGIX,
+    FfdTargetSGIX,
+    FogCoordinatePointerType,
+    FogMode,
+    FogPName,
+    FogParameter,
+    FogPointerTypeEXT,
+    FogPointerTypeIBM,
+    FragmentLightModelParameterSGIX,
+    FragmentOpATI,
+    FramebufferAttachment,
+    FramebufferAttachmentParameterName,
+    FramebufferFetchNoncoherent,
+    FramebufferParameterName,
+    FramebufferStatus,
+    FramebufferTarget,
+    FrontFaceDirection,
+    GetColorTableParameterPNameSGI,
+    GetConvolutionParameter,
+    GetFramebufferParameter,
+    GetHistogramParameterPNameEXT,
+    GetMapQuery,
+    GetMinmaxParameterPNameEXT,
+    GetPName,
+    GetPixelMap,
+    GetPointervPName,
+    GetTextureParameter,
+    GraphicsResetStatus,
+    HintMode,
+    HintTarget,
+    HistogramTargetEXT,
+    IndexPointerType,
+    InterleavedArrayFormat,
+    InternalFormat,
+    InternalFormatPName,
+    LightEnvModeSGIX,
+    LightEnvParameterSGIX,
+    LightModelColorControl,
+    LightModelParameter,
+    LightName,
+    LightParameter,
+    ListMode,
+    ListNameType,
+    ListParameterName,
+    LogicOp,
+    MapBufferUsageMask,
+    MapQuery,
+    MapTarget,
+    MapTextureFormatINTEL,
+    MaterialFace,
+    MaterialParameter,
+    MatrixMode,
+    MemoryBarrierMask,
+    MemoryObjectParameterName,
+    MeshMode1,
+    MeshMode2,
+    MinmaxTargetEXT,
+    NormalPointerType,
+    ObjectIdentifier,
+    OcclusionQueryEventMaskAMD,
+    PatchParameterName,
+    PathColor,
+    PathCoverMode,
+    PathElementType,
+    PathFillMode,
+    PathFontStyle,
+    PathFontTarget,
+    PathGenMode,
+    PathHandleMissingGlyphs,
+    PathListMode,
+    PathMetricMask,
+    PathParameter,
+    PathStringFormat,
+    PathTransformType,
+    PipelineParameterName,
+    PixelCopyType,
+    PixelFormat,
+    PixelMap,
+    PixelStoreParameter,
+    PixelStoreResampleMode,
+    PixelStoreSubsampleRate,
+    PixelTexGenMode,
+    PixelTexGenParameterNameSGIS,
+    PixelTransferParameter,
+    PixelType,
+    PointParameterNameSGIS,
+    PolygonMode,
+    PrecisionType,
+    PrimitiveType,
+    ProgramInterface,
+    ProgramInterfacePName,
+    ProgramParameterPName,
+    ProgramPropertyARB,
+    ProgramStagePName,
+    QueryObjectParameterName,
+    QueryParameterName,
+    QueryTarget,
+    ReadBufferMode,
+    RenderbufferParameterName,
+    RenderbufferTarget,
+    RenderingMode,
+    SamplePatternSGIS,
+    SamplerParameterName,
+    SemaphoreParameterName,
+    SeparableTargetEXT,
+    ShaderParameterName,
+    ShaderType,
+    ShadingModel,
+    StencilFaceDirection,
+    StencilFunction,
+    StencilOp,
+    StringName,
+    SubroutineParameterName,
+    SyncCondition,
+    SyncObjectMask,
+    SyncParameterName,
+    SyncStatus,
+    TexCoordPointerType,
+    TextureCoordName,
+    TextureEnvMode,
+    TextureEnvParameter,
+    TextureEnvTarget,
+    TextureFilterFuncSGIS,
+    TextureGenMode,
+    TextureGenParameter,
+    TextureLayout,
+    TextureMagFilter,
+    TextureMinFilter,
+    TextureParameterName,
+    TextureStorageMaskAMD,
+    TextureTarget,
+    TextureUnit,
+    TextureWrapMode,
+    TransformFeedbackPName,
+    TypeEnum,
+    UniformBlockPName,
+    UniformPName,
+    UseProgramStageMask,
+    VertexArrayPName,
+    VertexAttribEnum,
+    VertexAttribPointerType,
+    VertexAttribType,
+    VertexBufferObjectParameter,
+    VertexBufferObjectUsage,
+    VertexPointerType,
+    VertexProvokingMode
+};
+}  // namespace gl
+
+#endif  // LIBANGLE_GL_ENUM_UTILS_AUTOGEN_H_