Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

18 files changed, 19921 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..a9b0348b6a
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture.h
@@ -0,0 +1,1208 @@
+//
+// 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 interface.
+//
+
+#ifndef LIBANGLE_FRAME_CAPTURE_H_
+#define LIBANGLE_FRAME_CAPTURE_H_
+
+#include "common/PackedEnums.h"
+#include "common/system_utils.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 BigGLEnum;
+enum class GLESEnum;
+}  // namespace gl
+
+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::GLESEnum enumGroup;   // only used for param type GLenum, GLboolean and GLbitfield
+    gl::BigGLEnum bigGLEnum;  // only used for param type GLenum, GLboolean and GLbitfield
+    ParamData data;
+    int dataNElements           = 0;
+    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 setValueParamAtIndex(const char *paramName, ParamType paramType, T paramValue, int index);
+    template <typename T>
+    void addEnumParam(const char *paramName,
+                      gl::GLESEnum enumGroup,
+                      ParamType paramType,
+                      T paramValue);
+    template <typename T>
+    void addEnumParam(const char *paramName,
+                      gl::BigGLEnum 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;
+    bool isActive = true;
+};
+
+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(const std::vector<std::string> &str);
+    void setStringCounter(const 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;
+};
+
+class ReplayWriter final : angle::NonCopyable
+{
+  public:
+    ReplayWriter();
+    ~ReplayWriter();
+
+    void setSourceFileSizeThreshold(size_t sourceFileSizeThreshold);
+    void setFilenamePattern(const std::string &pattern);
+    void setCaptureLabel(const std::string &label);
+    void setSourcePrologue(const std::string &prologue);
+    void setHeaderPrologue(const std::string &prologue);
+
+    void addPublicFunction(const std::string &functionProto,
+                           const std::stringstream &headerStream,
+                           const std::stringstream &bodyStream);
+    void addPrivateFunction(const std::string &functionProto,
+                            const std::stringstream &headerStream,
+                            const std::stringstream &bodyStream);
+    std::string getInlineVariableName(EntryPoint entryPoint, const std::string &paramName);
+
+    std::string getInlineStringSetVariableName(EntryPoint entryPoint,
+                                               const std::string &paramName,
+                                               const std::vector<std::string> &strings,
+                                               bool *isNewEntryOut);
+
+    void saveFrame();
+    void saveFrameIfFull();
+    void saveIndexFilesAndHeader();
+    void saveSetupFile();
+
+    std::vector<std::string> getAndResetWrittenFiles();
+
+  private:
+    static std::string GetVarName(EntryPoint entryPoint, const std::string &paramName, int counter);
+
+    void saveHeader();
+    void writeReplaySource(const std::string &filename);
+    void addWrittenFile(const std::string &filename);
+    size_t getStoredReplaySourceSize() const;
+
+    size_t mSourceFileSizeThreshold;
+    size_t mFrameIndex;
+
+    DataTracker mDataTracker;
+    std::string mFilenamePattern;
+    std::string mCaptureLabel;
+    std::string mSourcePrologue;
+    std::string mHeaderPrologue;
+
+    std::vector<std::string> mReplayHeaders;
+    std::vector<std::string> mGlobalVariableDeclarations;
+
+    std::vector<std::string> mPublicFunctionPrototypes;
+    std::vector<std::string> mPublicFunctions;
+
+    std::vector<std::string> mPrivateFunctionPrototypes;
+    std::vector<std::string> mPrivateFunctions;
+
+    std::vector<std::string> mWrittenFiles;
+};
+
+using BufferCalls = std::map<GLuint, std::vector<CallCapture>>;
+
+// true means mapped, false means unmapped
+using BufferMapStatusMap = std::map<GLuint, bool>;
+
+using FenceSyncSet   = std::set<GLsync>;
+using FenceSyncCalls = std::map<GLsync, std::vector<CallCapture>>;
+
+// For default uniforms, we need to track which ones are dirty, and the series of calls to reset.
+// Each program has unique default uniforms, and each uniform has one or more locations in the
+// default buffer. For reset efficiency, we track only the uniforms dirty by location, per program.
+
+// A set of all default uniforms (per program) that were modified during the run
+using DefaultUniformLocationsSet = std::set<gl::UniformLocation>;
+using DefaultUniformLocationsPerProgramMap =
+    std::map<gl::ShaderProgramID, DefaultUniformLocationsSet>;
+
+// A map of programs which maps to locations and their reset calls
+using DefaultUniformCallsPerLocationMap = std::map<gl::UniformLocation, std::vector<CallCapture>>;
+using DefaultUniformCallsPerProgramMap =
+    std::map<gl::ShaderProgramID, DefaultUniformCallsPerLocationMap>;
+
+using DefaultUniformBaseLocationMap =
+    std::map<std::pair<gl::ShaderProgramID, gl::UniformLocation>, gl::UniformLocation>;
+
+using ResourceSet   = std::set<GLuint>;
+using ResourceCalls = std::map<GLuint, std::vector<CallCapture>>;
+
+class TrackedResource final : angle::NonCopyable
+{
+  public:
+    TrackedResource();
+    ~TrackedResource();
+
+    const ResourceSet &getStartingResources() const { return mStartingResources; }
+    ResourceSet &getStartingResources() { return mStartingResources; }
+    const ResourceSet &getNewResources() const { return mNewResources; }
+    ResourceSet &getNewResources() { return mNewResources; }
+    const ResourceSet &getResourcesToRegen() const { return mResourcesToRegen; }
+    ResourceSet &getResourcesToRegen() { return mResourcesToRegen; }
+    const ResourceSet &getResourcesToRestore() const { return mResourcesToRestore; }
+    ResourceSet &getResourcesToRestore() { return mResourcesToRestore; }
+
+    void setGennedResource(GLuint id);
+    void setDeletedResource(GLuint id);
+    void setModifiedResource(GLuint id);
+    bool resourceIsGenerated(GLuint id);
+
+    ResourceCalls &getResourceRegenCalls() { return mResourceRegenCalls; }
+    ResourceCalls &getResourceRestoreCalls() { return mResourceRestoreCalls; }
+
+  private:
+    // Resource regen calls will gen a resource
+    ResourceCalls mResourceRegenCalls;
+    // Resource restore calls will restore the contents of a resource
+    ResourceCalls mResourceRestoreCalls;
+
+    // Resources created during startup
+    ResourceSet mStartingResources;
+
+    // Resources created during the run that need to be deleted
+    ResourceSet mNewResources;
+    // Resources deleted during the run that need to be recreated
+    ResourceSet mResourcesToRegen;
+    // Resources modified during the run that need to be restored
+    ResourceSet mResourcesToRestore;
+};
+
+using TrackedResourceArray =
+    std::array<TrackedResource, static_cast<uint32_t>(ResourceIDType::EnumCount)>;
+
+// Helper to track resource changes during the capture
+class ResourceTracker final : angle::NonCopyable
+{
+  public:
+    ResourceTracker();
+    ~ResourceTracker();
+
+    BufferCalls &getBufferMapCalls() { return mBufferMapCalls; }
+    BufferCalls &getBufferUnmapCalls() { return mBufferUnmapCalls; }
+
+    std::vector<CallCapture> &getBufferBindingCalls() { return mBufferBindingCalls; }
+
+    void setBufferMapped(gl::ContextID contextID, GLuint id);
+    void setBufferUnmapped(gl::ContextID contextID, GLuint id);
+
+    bool getStartingBuffersMappedCurrent(GLuint id) const;
+    bool getStartingBuffersMappedInitial(GLuint id) const;
+
+    void setStartingBufferMapped(GLuint 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);
+
+    DefaultUniformLocationsPerProgramMap &getDefaultUniformsToReset()
+    {
+        return mDefaultUniformsToReset;
+    }
+    DefaultUniformCallsPerLocationMap &getDefaultUniformResetCalls(gl::ShaderProgramID id)
+    {
+        return mDefaultUniformResetCalls[id];
+    }
+    void setModifiedDefaultUniform(gl::ShaderProgramID programID, gl::UniformLocation location);
+    void setDefaultUniformBaseLocation(gl::ShaderProgramID programID,
+                                       gl::UniformLocation location,
+                                       gl::UniformLocation baseLocation);
+    gl::UniformLocation getDefaultUniformBaseLocation(gl::ShaderProgramID programID,
+                                                      gl::UniformLocation location)
+    {
+        ASSERT(mDefaultUniformBaseLocations.find({programID, location}) !=
+               mDefaultUniformBaseLocations.end());
+        return mDefaultUniformBaseLocations[{programID, location}];
+    }
+
+    TrackedResource &getTrackedResource(gl::ContextID contextID, ResourceIDType type);
+
+    void getContextIDs(std::set<gl::ContextID> &idsOut);
+
+    std::map<void *, egl::AttributeMap> &getImageToAttribTable() { return mMatchImageToAttribs; }
+
+    std::map<GLuint, void *> &getTextureIDToImageTable() { return mMatchTextureIDToImage; }
+
+  private:
+    // 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;
+
+    // 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;
+
+    // Default uniforms that were modified during the run
+    DefaultUniformLocationsPerProgramMap mDefaultUniformsToReset;
+    // Calls per default uniform to return to original state
+    DefaultUniformCallsPerProgramMap mDefaultUniformResetCalls;
+
+    // Base location of arrayed uniforms
+    DefaultUniformBaseLocationMap mDefaultUniformBaseLocations;
+
+    // Tracked resources per context
+    TrackedResourceArray mTrackedResourcesShared;
+    std::map<gl::ContextID, TrackedResourceArray> mTrackedResourcesPerContext;
+
+    std::map<void *, egl::AttributeMap> mMatchImageToAttribs;
+    std::map<GLuint, void *> mMatchTextureIDToImage;
+};
+
+// Used by the CPP replay to filter out unnecessary code.
+using HasResourceTypeMap = angle::PackedEnumBitSet<ResourceIDType>;
+
+// Map of ResourceType to IDs and range of setup calls
+using ResourceIDToSetupCallsMap =
+    PackedEnumMap<ResourceIDType, std::map<GLuint, gl::Range<size_t>>>;
+
+// 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>;
+
+struct SurfaceParams
+{
+    gl::Extents extents;
+    egl::ColorSpace colorSpace;
+};
+
+// Map from ContextID to SurfaceParams
+using SurfaceParamsMap = std::map<gl::ContextID, SurfaceParams>;
+
+using CallVector = std::vector<std::vector<CallCapture> *>;
+
+// A map from API entry point to calls
+using CallResetMap = std::map<angle::EntryPoint, std::vector<CallCapture>>;
+
+// StateResetHelper provides a simple way to track whether an entry point has been called during the
+// trace, along with the reset calls to get it back to starting state.  This is useful for things
+// that are one dimensional, like context bindings or context state.
+class StateResetHelper final : angle::NonCopyable
+{
+  public:
+    StateResetHelper();
+    ~StateResetHelper();
+
+    const std::set<angle::EntryPoint> &getDirtyEntryPoints() const { return mDirtyEntryPoints; }
+    void setEntryPointDirty(EntryPoint entryPoint) { mDirtyEntryPoints.insert(entryPoint); }
+
+    CallResetMap &getResetCalls() { return mResetCalls; }
+    const CallResetMap &getResetCalls() const { return mResetCalls; }
+
+    void setDefaultResetCalls(const gl::Context *context, angle::EntryPoint);
+
+  private:
+    // Dirty state per entry point
+    std::set<angle::EntryPoint> mDirtyEntryPoints;
+
+    // Reset calls per API entry point
+    CallResetMap mResetCalls;
+};
+
+class FrameCapture final : angle::NonCopyable
+{
+  public:
+    FrameCapture();
+    ~FrameCapture();
+
+    std::vector<CallCapture> &getSetupCalls() { return mSetupCalls; }
+    void clearSetupCalls() { mSetupCalls.clear(); }
+
+    StateResetHelper &getStateResetHelper() { return mStateResetHelper; }
+
+    void reset();
+
+  private:
+    std::vector<CallCapture> mSetupCalls;
+
+    StateResetHelper mStateResetHelper;
+};
+
+// Page range inside a coherent buffer
+struct PageRange
+{
+    PageRange(size_t start, size_t end);
+    ~PageRange();
+
+    // Relative start page
+    size_t start;
+
+    // First page after the relative end
+    size_t end;
+};
+
+// Memory address range defined by start and size
+struct AddressRange
+{
+    AddressRange();
+    AddressRange(uintptr_t start, size_t size);
+    ~AddressRange();
+
+    uintptr_t end();
+
+    uintptr_t start;
+    size_t size;
+};
+
+// Used to handle protection of buffers that overlap in pages.
+enum class PageSharingType
+{
+    NoneShared,
+    FirstShared,
+    LastShared,
+    FirstAndLastShared
+};
+
+class CoherentBuffer
+{
+  public:
+    CoherentBuffer(uintptr_t start, size_t size, size_t pageSize);
+    ~CoherentBuffer();
+
+    // Sets the a range in the buffer clean and protects a selected range
+    void protectPageRange(const PageRange &pageRange);
+
+    // Sets a page dirty state and sets it's protection
+    void setDirty(size_t relativePage, bool dirty);
+
+    // Removes protection
+    void removeProtection(PageSharingType sharingType);
+
+    bool contains(size_t page, size_t *relativePage);
+    bool isDirty();
+
+    // Returns dirty page ranges
+    std::vector<PageRange> getDirtyPageRanges();
+
+    // Calculates address range from page range
+    AddressRange getDirtyAddressRange(const PageRange &dirtyPageRange);
+    AddressRange getRange();
+
+  private:
+    // Actual buffer start and size
+    AddressRange mRange;
+
+    // Start and size of page aligned protected area
+    AddressRange mProtectionRange;
+
+    // Start and end of protection in relative pages, calculated from mProtectionRange.
+    size_t mProtectionStartPage;
+    size_t mProtectionEndPage;
+
+    size_t mPageCount;
+    size_t mPageSize;
+
+    // Clean pages are protected
+    std::vector<bool> mDirtyPages;
+};
+
+class CoherentBufferTracker final : angle::NonCopyable
+{
+  public:
+    CoherentBufferTracker();
+    ~CoherentBufferTracker();
+
+    bool isDirty(gl::BufferID id);
+    void addBuffer(gl::BufferID id, uintptr_t start, size_t size);
+    void removeBuffer(gl::BufferID id);
+    void disable();
+    void enable();
+    void onEndFrame();
+
+  private:
+    // Detect overlapping pages when removing protection
+    PageSharingType doesBufferSharePage(gl::BufferID id);
+
+    // Returns a map to found buffers and the corresponding pages for a given address.
+    // For addresses that are in a page shared by 2 buffers, 2 results are returned.
+    HashMap<std::shared_ptr<CoherentBuffer>, size_t> getBufferPagesForAddress(uintptr_t address);
+    PageFaultHandlerRangeType handleWrite(uintptr_t address);
+    bool haveBuffer(gl::BufferID id);
+
+  public:
+    std::mutex mMutex;
+    HashMap<GLuint, std::shared_ptr<CoherentBuffer>> mBuffers;
+
+  private:
+    bool mEnabled = false;
+    std::unique_ptr<PageFaultHandler> mPageFaultHandler;
+    size_t mPageSize;
+};
+
+// Shared class for any items that need to be tracked by FrameCapture across shared contexts
+class FrameCaptureShared final : angle::NonCopyable
+{
+  public:
+    FrameCaptureShared();
+    ~FrameCaptureShared();
+
+    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(const gl::Context *context,
+                            CallCapture *call,
+                            gl::BufferID id,
+                            gl::Buffer *buffer,
+                            GLintptr offset,
+                            GLsizeiptr length,
+                            bool writable,
+                            bool coherent);
+
+    void trackTextureUpdate(const gl::Context *context, const CallCapture &call);
+    void trackDefaultUniformUpdate(const gl::Context *context, const CallCapture &call);
+    void trackVertexArrayUpdate(const gl::Context *context, const CallCapture &call);
+
+    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);
+
+    // Capture coherent buffer storages
+    void captureCoherentBufferSnapshot(const gl::Context *context, gl::BufferID bufferID);
+
+    // Remove any cached texture levels on deletion
+    void deleteCachedTextureLevelData(gl::TextureID id);
+
+    void eraseBufferDataMapEntry(const gl::BufferID bufferId)
+    {
+        const auto &bufferDataInfo = mBufferDataMap.find(bufferId);
+        if (bufferDataInfo != mBufferDataMap.end())
+        {
+            mBufferDataMap.erase(bufferDataInfo);
+        }
+    }
+
+    bool hasBufferData(gl::BufferID bufferID)
+    {
+        const auto &bufferDataInfo = mBufferDataMap.find(bufferID);
+        if (bufferDataInfo != mBufferDataMap.end())
+        {
+            return true;
+        }
+        return false;
+    }
+
+    std::pair<GLintptr, GLsizeiptr> getBufferDataOffsetAndLength(gl::BufferID bufferID)
+    {
+        const auto &bufferDataInfo = mBufferDataMap.find(bufferID);
+        ASSERT(bufferDataInfo != mBufferDataMap.end());
+        return bufferDataInfo->second;
+    }
+
+    void setCaptureActive() { mCaptureActive = true; }
+    void setCaptureInactive() { mCaptureActive = false; }
+    bool isCaptureActive() { return mCaptureActive; }
+    bool usesMidExecutionCapture() { return mCaptureStartFrame > 1; }
+
+    gl::ContextID getWindowSurfaceContextID() const { return mWindowSurfaceContextID; }
+
+    void markResourceSetupCallsInactive(std::vector<CallCapture> *setupCalls,
+                                        ResourceIDType type,
+                                        GLuint id,
+                                        gl::Range<size_t> range);
+
+    void updateReadBufferSize(size_t readBufferSize)
+    {
+        mReadBufferSize = std::max(mReadBufferSize, readBufferSize);
+    }
+
+    template <typename ResourceType>
+    void handleGennedResource(const gl::Context *context, ResourceType resourceID)
+    {
+        if (isCaptureActive())
+        {
+            ResourceIDType idType    = GetResourceIDTypeFromType<ResourceType>::IDType;
+            TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType);
+            tracker.setGennedResource(resourceID.value);
+        }
+    }
+
+    template <typename ResourceType>
+    bool resourceIsGenerated(const gl::Context *context, ResourceType resourceID)
+    {
+        ResourceIDType idType    = GetResourceIDTypeFromType<ResourceType>::IDType;
+        TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType);
+        return tracker.resourceIsGenerated(resourceID.value);
+    }
+
+    template <typename ResourceType>
+    void handleDeletedResource(const gl::Context *context, ResourceType resourceID)
+    {
+        if (isCaptureActive())
+        {
+            ResourceIDType idType    = GetResourceIDTypeFromType<ResourceType>::IDType;
+            TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType);
+            tracker.setDeletedResource(resourceID.value);
+        }
+    }
+
+  private:
+    void writeJSON(const gl::Context *context);
+    void writeCppReplayIndexFiles(const gl::Context *context, bool writeResetContextCall);
+    void writeMainContextCppReplay(const gl::Context *context,
+                                   const std::vector<CallCapture> &setupCalls,
+                                   StateResetHelper &StateResetHelper);
+
+    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,
+                                 std::vector<CallCapture> &newCalls);
+    void maybeCapturePreCallUpdates(const gl::Context *context,
+                                    CallCapture &call,
+                                    std::vector<CallCapture> *shareGroupSetupCalls,
+                                    ResourceIDToSetupCallsMap *resourceIDToSetupCalls);
+    template <typename ParamValueType>
+    void maybeGenResourceOnBind(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);
+    void maybeCaptureCoherentBuffers(const gl::Context *context);
+    void updateCopyImageSubData(CallCapture &call);
+    void overrideProgramBinary(const gl::Context *context,
+                               CallCapture &call,
+                               std::vector<CallCapture> &outCalls);
+    void updateResourceCountsFromParamCapture(const ParamCapture &param, ResourceIDType idType);
+    void updateResourceCountsFromCallCapture(const CallCapture &call);
+
+    void runMidExecutionCapture(const gl::Context *context);
+
+    void scanSetupCalls(const gl::Context *context, std::vector<CallCapture> &setupCalls);
+
+    static void ReplayCall(gl::Context *context,
+                           ReplayContext *replayContext,
+                           const CallCapture &call);
+
+    std::vector<CallCapture> mFrameCalls;
+    gl::ContextID mLastContextId;
+
+    // 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;
+    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;
+    SurfaceParamsMap mDrawSurfaceParams;
+    gl::AttribArray<size_t> mClientArraySizes;
+    size_t mReadBufferSize;
+    HasResourceTypeMap mHasResourceType;
+    ResourceIDToSetupCallsMap mResourceIDToSetupCalls;
+    BufferDataMap mBufferDataMap;
+    bool mValidateSerializedState = false;
+    std::string mValidationExpression;
+    bool mTrimEnabled = true;
+    PackedEnumMap<ResourceIDType, uint32_t> mMaxAccessedResourceIDs;
+    CoherentBufferTracker mCoherentBufferTracker;
+
+    ResourceTracker mResourceTracker;
+    ReplayWriter mReplayWriter;
+
+    // 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;
+    std::vector<uint32_t> mActiveFrameIndices;
+
+    // Cache most recently compiled and linked sources.
+    ShaderSourceMap mCachedShaderSource;
+    ProgramSourceMap mCachedProgramSources;
+
+    gl::ContextID mWindowSurfaceContextID;
+
+    std::vector<CallCapture> mShareGroupSetupCalls;
+};
+
+template <typename CaptureFuncT, typename... ArgsT>
+void CaptureCallToFrameCapture(CaptureFuncT captureFunc,
+                               bool isCallValid,
+                               gl::Context *context,
+                               ArgsT... captureParams)
+{
+    FrameCaptureShared *frameCaptureShared = context->getShareGroup()->getFrameCaptureShared();
+    if (!frameCaptureShared->isCapturing())
+    {
+        return;
+    }
+
+    CallCapture call = captureFunc(context->getState(), isCallValid, captureParams...);
+
+    frameCaptureShared->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::setValueParamAtIndex(const char *paramName,
+                                       ParamType paramType,
+                                       T paramValue,
+                                       int index)
+{
+    ASSERT(mParamCaptures.size() > static_cast<size_t>(index));
+
+    ParamCapture capture(paramName, paramType);
+    InitParamValue(paramType, paramValue, &capture.value);
+    mParamCaptures[index] = std::move(capture);
+}
+
+template <typename T>
+void ParamBuffer::addEnumParam(const char *paramName,
+                               gl::GLESEnum enumGroup,
+                               ParamType paramType,
+                               T paramValue)
+{
+    ParamCapture capture(paramName, paramType);
+    InitParamValue(paramType, paramValue, &capture.value);
+    capture.enumGroup = enumGroup;
+    mParamCaptures.emplace_back(std::move(capture));
+}
+
+template <typename T>
+void ParamBuffer::addEnumParam(const char *paramName,
+                               gl::BigGLEnum enumGroup,
+                               ParamType paramType,
+                               T paramValue)
+{
+    ParamCapture capture(paramName, paramType);
+    InitParamValue(paramType, paramValue, &capture.value);
+    capture.bigGLEnum = enumGroup;
+    mParamCaptures.emplace_back(std::move(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)
+{
+    paramCapture->dataNElements = n;
+    CaptureGenHandlesImpl(n, reinterpret_cast<GLuint *>(handles), paramCapture);
+}
+
+template <typename T>
+void CaptureArray(T *elements, GLsizei n, ParamCapture *paramCapture)
+{
+    paramCapture->dataNElements = n;
+    CaptureMemory(elements, n * sizeof(T), 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::TGLbooleanPointer>(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::TvoidPointer>(std::ostream &os,
+                                                    const CallCapture &call,
+                                                    void *value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLfloatConstPointer>(std::ostream &os,
+                                                            const CallCapture &call,
+                                                            const GLfloat *value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLintConstPointer>(std::ostream &os,
+                                                          const CallCapture &call,
+                                                          const GLint *value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLsizeiPointer>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       GLsizei *value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLuintConstPointer>(std::ostream &os,
+                                                           const CallCapture &call,
+                                                           const GLuint *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);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLeglImageOES>(std::ostream &os,
+                                                      const CallCapture &call,
+                                                      GLeglImageOES value);
+
+template <>
+void WriteParamValueReplay<ParamType::TGLubyte>(std::ostream &os,
+                                                const CallCapture &call,
+                                                GLubyte value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLContext>(std::ostream &os,
+                                                   const CallCapture &call,
+                                                   EGLContext value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLDisplay>(std::ostream &os,
+                                                   const CallCapture &call,
+                                                   EGLContext value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLSurface>(std::ostream &os,
+                                                   const CallCapture &call,
+                                                   EGLContext value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLDEBUGPROCKHR>(std::ostream &os,
+                                                        const CallCapture &call,
+                                                        EGLDEBUGPROCKHR value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLGetBlobFuncANDROID>(std::ostream &os,
+                                                              const CallCapture &call,
+                                                              EGLGetBlobFuncANDROID value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLSetBlobFuncANDROID>(std::ostream &os,
+                                                              const CallCapture &call,
+                                                              EGLSetBlobFuncANDROID value);
+template <>
+void WriteParamValueReplay<ParamType::TEGLClientBuffer>(std::ostream &os,
+                                                        const CallCapture &call,
+                                                        EGLClientBuffer value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLConfig>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  EGLConfig value);
+
+template <>
+void WriteParamValueReplay<ParamType::TEGLSurface>(std::ostream &os,
+                                                   const CallCapture &call,
+                                                   EGLSurface 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 || pname == GL_TEXTURE_CROP_RECT_OES)
+    {
+        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..dc9e44c5bb
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture_mock.cpp
@@ -0,0 +1,55 @@
+//
+// 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() {}
+TrackedResource::TrackedResource() {}
+TrackedResource::~TrackedResource() {}
+StateResetHelper::StateResetHelper() {}
+StateResetHelper::~StateResetHelper() {}
+DataTracker::DataTracker() {}
+DataTracker::~DataTracker() {}
+DataCounters::DataCounters() {}
+DataCounters::~DataCounters() {}
+StringCounters::StringCounters() {}
+StringCounters::~StringCounters() {}
+ReplayWriter::ReplayWriter() {}
+ReplayWriter::~ReplayWriter() {}
+
+FrameCapture::FrameCapture() {}
+FrameCapture::~FrameCapture() {}
+
+FrameCaptureShared::FrameCaptureShared() : mEnabled(false) {}
+FrameCaptureShared::~FrameCaptureShared() {}
+void FrameCaptureShared::onEndFrame(const gl::Context *context) {}
+void FrameCaptureShared::onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface)
+{}
+void FrameCaptureShared::onDestroyContext(const gl::Context *context) {}
+void FrameCaptureShared::replay(gl::Context *context) {}
+const ProgramSources &FrameCaptureShared::getProgramSources(gl::ShaderProgramID id) const
+{
+    const auto &foundSources = mCachedProgramSources.find(id);
+    return foundSources->second;
+}
+void FrameCaptureShared::setProgramSources(gl::ShaderProgramID id, ProgramSources sources) {}
+
+CoherentBufferTracker::CoherentBufferTracker() {}
+CoherentBufferTracker::~CoherentBufferTracker() {}
+}  // namespace angle
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_egl.h b/gfx/angle/checkout/src/libANGLE/capture/capture_egl.h
new file mode 100644
index 0000000000..f23bc1a2ce
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_egl.h
@@ -0,0 +1,69 @@
+//
+// Copyright 2022 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_egl.h:
+//   EGL capture functions
+//
+
+#ifndef LIBANGLE_CAPTURE_EGL_H_
+#define LIBANGLE_CAPTURE_EGL_H_
+
+#include "libANGLE/Context.h"
+#include "libANGLE/Thread.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+enum class GLenumGroup;
+}
+
+namespace egl
+{
+
+template <typename CaptureFuncT, typename... ArgsT>
+void CaptureCallToCaptureEGL(CaptureFuncT captureFunc, egl::Thread *thread, ArgsT... captureParams)
+{
+    gl::Context *context = thread->getContext();
+    if (!context)
+    {
+        return;
+    }
+
+    angle::FrameCaptureShared *frameCaptureShared =
+        context->getShareGroup()->getFrameCaptureShared();
+    if (!frameCaptureShared->isCapturing())
+    {
+        return;
+    }
+
+    angle::CallCapture call = captureFunc(captureParams...);
+
+    frameCaptureShared->captureCall(context, std::move(call), true);
+}
+
+angle::CallCapture CaptureCreateNativeClientBufferANDROID(const egl::AttributeMap &attribMap,
+                                                          EGLClientBuffer eglClientBuffer);
+angle::CallCapture CaptureEGLCreateImage(const gl::Context *context,
+                                         EGLenum target,
+                                         EGLClientBuffer buffer,
+                                         const egl::AttributeMap &attributes,
+                                         egl::Image *image);
+angle::CallCapture CaptureEGLDestroyImage(egl::Display *display, egl::Image *image);
+
+angle::CallCapture CaptureEGLCreatePbufferSurface(const AttributeMap &attrib_list,
+                                                  egl::Surface *surface);
+
+angle::CallCapture CaptureEGLDestroySurface(Display *display, Surface *surface);
+
+angle::CallCapture CaptureEGLBindTexImage(egl::Surface *surface, EGLint buffer);
+
+angle::CallCapture CaptureEGLReleaseTexImage(egl::Surface *surface, EGLint buffer);
+
+angle::CallCapture CaptureEGLMakeCurrent(Surface *drawSurface,
+                                         Surface *readSurface,
+                                         gl::Context *context);
+}  // namespace egl
+
+#endif  // LIBANGLE_FRAME_CAPTURE_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gl_1_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_1_autogen.h
new file mode 100644
index 0000000000..7e4eea7af1
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_1_autogen.h
@@ -0,0 +1,2072 @@
+// 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_gl_1_autogen.h:
+//   Capture functions for the OpenGL ES Desktop GL 1.x entry points.
+
+#ifndef LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+// GL 1.0
+angle::CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfloat value);
+angle::CallCapture CaptureBegin(const State &glState, bool isCallValid, GLenum mode);
+angle::CallCapture CaptureBitmap(const State &glState,
+                                 bool isCallValid,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLfloat xorig,
+                                 GLfloat yorig,
+                                 GLfloat xmove,
+                                 GLfloat ymove,
+                                 const GLubyte *bitmap);
+angle::CallCapture CaptureCallList(const State &glState, bool isCallValid, GLuint list);
+angle::CallCapture CaptureCallLists(const State &glState,
+                                    bool isCallValid,
+                                    GLsizei n,
+                                    GLenum type,
+                                    const void *lists);
+angle::CallCapture CaptureClearAccum(const State &glState,
+                                     bool isCallValid,
+                                     GLfloat red,
+                                     GLfloat green,
+                                     GLfloat blue,
+                                     GLfloat alpha);
+angle::CallCapture CaptureClearDepth(const State &glState, bool isCallValid, GLdouble depth);
+angle::CallCapture CaptureClearIndex(const State &glState, bool isCallValid, GLfloat c);
+angle::CallCapture CaptureClipPlane(const State &glState,
+                                    bool isCallValid,
+                                    GLenum plane,
+                                    const GLdouble *equation);
+angle::CallCapture CaptureColor3b(const State &glState,
+                                  bool isCallValid,
+                                  GLbyte red,
+                                  GLbyte green,
+                                  GLbyte blue);
+angle::CallCapture CaptureColor3bv(const State &glState, bool isCallValid, const GLbyte *v);
+angle::CallCapture CaptureColor3d(const State &glState,
+                                  bool isCallValid,
+                                  GLdouble red,
+                                  GLdouble green,
+                                  GLdouble blue);
+angle::CallCapture CaptureColor3dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureColor3f(const State &glState,
+                                  bool isCallValid,
+                                  GLfloat red,
+                                  GLfloat green,
+                                  GLfloat blue);
+angle::CallCapture CaptureColor3fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureColor3i(const State &glState,
+                                  bool isCallValid,
+                                  GLint red,
+                                  GLint green,
+                                  GLint blue);
+angle::CallCapture CaptureColor3iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureColor3s(const State &glState,
+                                  bool isCallValid,
+                                  GLshort red,
+                                  GLshort green,
+                                  GLshort blue);
+angle::CallCapture CaptureColor3sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureColor3ub(const State &glState,
+                                   bool isCallValid,
+                                   GLubyte red,
+                                   GLubyte green,
+                                   GLubyte blue);
+angle::CallCapture CaptureColor3ubv(const State &glState, bool isCallValid, const GLubyte *v);
+angle::CallCapture CaptureColor3ui(const State &glState,
+                                   bool isCallValid,
+                                   GLuint red,
+                                   GLuint green,
+                                   GLuint blue);
+angle::CallCapture CaptureColor3uiv(const State &glState, bool isCallValid, const GLuint *v);
+angle::CallCapture CaptureColor3us(const State &glState,
+                                   bool isCallValid,
+                                   GLushort red,
+                                   GLushort green,
+                                   GLushort blue);
+angle::CallCapture CaptureColor3usv(const State &glState, bool isCallValid, const GLushort *v);
+angle::CallCapture CaptureColor4b(const State &glState,
+                                  bool isCallValid,
+                                  GLbyte red,
+                                  GLbyte green,
+                                  GLbyte blue,
+                                  GLbyte alpha);
+angle::CallCapture CaptureColor4bv(const State &glState, bool isCallValid, const GLbyte *v);
+angle::CallCapture CaptureColor4d(const State &glState,
+                                  bool isCallValid,
+                                  GLdouble red,
+                                  GLdouble green,
+                                  GLdouble blue,
+                                  GLdouble alpha);
+angle::CallCapture CaptureColor4dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureColor4fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureColor4i(const State &glState,
+                                  bool isCallValid,
+                                  GLint red,
+                                  GLint green,
+                                  GLint blue,
+                                  GLint alpha);
+angle::CallCapture CaptureColor4iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureColor4s(const State &glState,
+                                  bool isCallValid,
+                                  GLshort red,
+                                  GLshort green,
+                                  GLshort blue,
+                                  GLshort alpha);
+angle::CallCapture CaptureColor4sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureColor4ubv(const State &glState, bool isCallValid, const GLubyte *v);
+angle::CallCapture CaptureColor4ui(const State &glState,
+                                   bool isCallValid,
+                                   GLuint red,
+                                   GLuint green,
+                                   GLuint blue,
+                                   GLuint alpha);
+angle::CallCapture CaptureColor4uiv(const State &glState, bool isCallValid, const GLuint *v);
+angle::CallCapture CaptureColor4us(const State &glState,
+                                   bool isCallValid,
+                                   GLushort red,
+                                   GLushort green,
+                                   GLushort blue,
+                                   GLushort alpha);
+angle::CallCapture CaptureColor4usv(const State &glState, bool isCallValid, const GLushort *v);
+angle::CallCapture CaptureColorMaterial(const State &glState,
+                                        bool isCallValid,
+                                        GLenum face,
+                                        GLenum mode);
+angle::CallCapture CaptureCopyPixels(const State &glState,
+                                     bool isCallValid,
+                                     GLint x,
+                                     GLint y,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLenum type);
+angle::CallCapture CaptureDeleteLists(const State &glState,
+                                      bool isCallValid,
+                                      GLuint list,
+                                      GLsizei range);
+angle::CallCapture CaptureDepthRange(const State &glState,
+                                     bool isCallValid,
+                                     GLdouble n,
+                                     GLdouble f);
+angle::CallCapture CaptureDrawBuffer(const State &glState, bool isCallValid, GLenum buf);
+angle::CallCapture CaptureDrawPixels(const State &glState,
+                                     bool isCallValid,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLenum format,
+                                     GLenum type,
+                                     const void *pixels);
+angle::CallCapture CaptureEdgeFlag(const State &glState, bool isCallValid, GLboolean flag);
+angle::CallCapture CaptureEdgeFlagv(const State &glState, bool isCallValid, const GLboolean *flag);
+angle::CallCapture CaptureEnd(const State &glState, bool isCallValid);
+angle::CallCapture CaptureEndList(const State &glState, bool isCallValid);
+angle::CallCapture CaptureEvalCoord1d(const State &glState, bool isCallValid, GLdouble u);
+angle::CallCapture CaptureEvalCoord1dv(const State &glState, bool isCallValid, const GLdouble *u);
+angle::CallCapture CaptureEvalCoord1f(const State &glState, bool isCallValid, GLfloat u);
+angle::CallCapture CaptureEvalCoord1fv(const State &glState, bool isCallValid, const GLfloat *u);
+angle::CallCapture CaptureEvalCoord2d(const State &glState,
+                                      bool isCallValid,
+                                      GLdouble u,
+                                      GLdouble v);
+angle::CallCapture CaptureEvalCoord2dv(const State &glState, bool isCallValid, const GLdouble *u);
+angle::CallCapture CaptureEvalCoord2f(const State &glState, bool isCallValid, GLfloat u, GLfloat v);
+angle::CallCapture CaptureEvalCoord2fv(const State &glState, bool isCallValid, const GLfloat *u);
+angle::CallCapture CaptureEvalMesh1(const State &glState,
+                                    bool isCallValid,
+                                    GLenum mode,
+                                    GLint i1,
+                                    GLint i2);
+angle::CallCapture CaptureEvalMesh2(const State &glState,
+                                    bool isCallValid,
+                                    GLenum mode,
+                                    GLint i1,
+                                    GLint i2,
+                                    GLint j1,
+                                    GLint j2);
+angle::CallCapture CaptureEvalPoint1(const State &glState, bool isCallValid, GLint i);
+angle::CallCapture CaptureEvalPoint2(const State &glState, bool isCallValid, GLint i, GLint j);
+angle::CallCapture CaptureFeedbackBuffer(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei size,
+                                         GLenum type,
+                                         GLfloat *buffer);
+angle::CallCapture CaptureFogi(const State &glState, bool isCallValid, GLenum pname, GLint param);
+angle::CallCapture CaptureFogiv(const State &glState,
+                                bool isCallValid,
+                                GLenum pname,
+                                const GLint *params);
+angle::CallCapture CaptureFrustum(const State &glState,
+                                  bool isCallValid,
+                                  GLdouble left,
+                                  GLdouble right,
+                                  GLdouble bottom,
+                                  GLdouble top,
+                                  GLdouble zNear,
+                                  GLdouble zFar);
+angle::CallCapture CaptureGenLists(const State &glState,
+                                   bool isCallValid,
+                                   GLsizei range,
+                                   GLuint returnValue);
+angle::CallCapture CaptureGetClipPlane(const State &glState,
+                                       bool isCallValid,
+                                       GLenum plane,
+                                       GLdouble *equation);
+angle::CallCapture CaptureGetDoublev(const State &glState,
+                                     bool isCallValid,
+                                     GLenum pname,
+                                     GLdouble *data);
+angle::CallCapture CaptureGetLightiv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum light,
+                                     GLenum pname,
+                                     GLint *params);
+angle::CallCapture CaptureGetMapdv(const State &glState,
+                                   bool isCallValid,
+                                   GLenum target,
+                                   GLenum query,
+                                   GLdouble *v);
+angle::CallCapture CaptureGetMapfv(const State &glState,
+                                   bool isCallValid,
+                                   GLenum target,
+                                   GLenum query,
+                                   GLfloat *v);
+angle::CallCapture CaptureGetMapiv(const State &glState,
+                                   bool isCallValid,
+                                   GLenum target,
+                                   GLenum query,
+                                   GLint *v);
+angle::CallCapture CaptureGetMaterialiv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum face,
+                                        GLenum pname,
+                                        GLint *params);
+angle::CallCapture CaptureGetPixelMapfv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum map,
+                                        GLfloat *values);
+angle::CallCapture CaptureGetPixelMapuiv(const State &glState,
+                                         bool isCallValid,
+                                         GLenum map,
+                                         GLuint *values);
+angle::CallCapture CaptureGetPixelMapusv(const State &glState,
+                                         bool isCallValid,
+                                         GLenum map,
+                                         GLushort *values);
+angle::CallCapture CaptureGetPolygonStipple(const State &glState, bool isCallValid, GLubyte *mask);
+angle::CallCapture CaptureGetTexGendv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      GLdouble *params);
+angle::CallCapture CaptureGetTexGenfv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      GLfloat *params);
+angle::CallCapture CaptureGetTexGeniv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      GLint *params);
+angle::CallCapture CaptureGetTexImage(const State &glState,
+                                      bool isCallValid,
+                                      TextureTarget targetPacked,
+                                      GLint level,
+                                      GLenum format,
+                                      GLenum type,
+                                      void *pixels);
+angle::CallCapture CaptureIndexMask(const State &glState, bool isCallValid, GLuint mask);
+angle::CallCapture CaptureIndexd(const State &glState, bool isCallValid, GLdouble c);
+angle::CallCapture CaptureIndexdv(const State &glState, bool isCallValid, const GLdouble *c);
+angle::CallCapture CaptureIndexf(const State &glState, bool isCallValid, GLfloat c);
+angle::CallCapture CaptureIndexfv(const State &glState, bool isCallValid, const GLfloat *c);
+angle::CallCapture CaptureIndexi(const State &glState, bool isCallValid, GLint c);
+angle::CallCapture CaptureIndexiv(const State &glState, bool isCallValid, const GLint *c);
+angle::CallCapture CaptureIndexs(const State &glState, bool isCallValid, GLshort c);
+angle::CallCapture CaptureIndexsv(const State &glState, bool isCallValid, const GLshort *c);
+angle::CallCapture CaptureInitNames(const State &glState, bool isCallValid);
+angle::CallCapture CaptureIsList(const State &glState,
+                                 bool isCallValid,
+                                 GLuint list,
+                                 GLboolean returnValue);
+angle::CallCapture CaptureLightModeli(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      GLint param);
+angle::CallCapture CaptureLightModeliv(const State &glState,
+                                       bool isCallValid,
+                                       GLenum pname,
+                                       const GLint *params);
+angle::CallCapture CaptureLighti(const State &glState,
+                                 bool isCallValid,
+                                 GLenum light,
+                                 GLenum pname,
+                                 GLint param);
+angle::CallCapture CaptureLightiv(const State &glState,
+                                  bool isCallValid,
+                                  GLenum light,
+                                  GLenum pname,
+                                  const GLint *params);
+angle::CallCapture CaptureLineStipple(const State &glState,
+                                      bool isCallValid,
+                                      GLint factor,
+                                      GLushort pattern);
+angle::CallCapture CaptureListBase(const State &glState, bool isCallValid, GLuint base);
+angle::CallCapture CaptureLoadMatrixd(const State &glState, bool isCallValid, const GLdouble *m);
+angle::CallCapture CaptureLoadName(const State &glState, bool isCallValid, GLuint name);
+angle::CallCapture CaptureMap1d(const State &glState,
+                                bool isCallValid,
+                                GLenum target,
+                                GLdouble u1,
+                                GLdouble u2,
+                                GLint stride,
+                                GLint order,
+                                const GLdouble *points);
+angle::CallCapture CaptureMap1f(const State &glState,
+                                bool isCallValid,
+                                GLenum target,
+                                GLfloat u1,
+                                GLfloat u2,
+                                GLint stride,
+                                GLint order,
+                                const GLfloat *points);
+angle::CallCapture CaptureMap2d(const State &glState,
+                                bool isCallValid,
+                                GLenum target,
+                                GLdouble u1,
+                                GLdouble u2,
+                                GLint ustride,
+                                GLint uorder,
+                                GLdouble v1,
+                                GLdouble v2,
+                                GLint vstride,
+                                GLint vorder,
+                                const GLdouble *points);
+angle::CallCapture CaptureMap2f(const State &glState,
+                                bool isCallValid,
+                                GLenum target,
+                                GLfloat u1,
+                                GLfloat u2,
+                                GLint ustride,
+                                GLint uorder,
+                                GLfloat v1,
+                                GLfloat v2,
+                                GLint vstride,
+                                GLint vorder,
+                                const GLfloat *points);
+angle::CallCapture CaptureMapGrid1d(const State &glState,
+                                    bool isCallValid,
+                                    GLint un,
+                                    GLdouble u1,
+                                    GLdouble u2);
+angle::CallCapture CaptureMapGrid1f(const State &glState,
+                                    bool isCallValid,
+                                    GLint un,
+                                    GLfloat u1,
+                                    GLfloat u2);
+angle::CallCapture CaptureMapGrid2d(const State &glState,
+                                    bool isCallValid,
+                                    GLint un,
+                                    GLdouble u1,
+                                    GLdouble u2,
+                                    GLint vn,
+                                    GLdouble v1,
+                                    GLdouble v2);
+angle::CallCapture CaptureMapGrid2f(const State &glState,
+                                    bool isCallValid,
+                                    GLint un,
+                                    GLfloat u1,
+                                    GLfloat u2,
+                                    GLint vn,
+                                    GLfloat v1,
+                                    GLfloat v2);
+angle::CallCapture CaptureMateriali(const State &glState,
+                                    bool isCallValid,
+                                    GLenum face,
+                                    GLenum pname,
+                                    GLint param);
+angle::CallCapture CaptureMaterialiv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum face,
+                                     GLenum pname,
+                                     const GLint *params);
+angle::CallCapture CaptureMultMatrixd(const State &glState, bool isCallValid, const GLdouble *m);
+angle::CallCapture CaptureNewList(const State &glState, bool isCallValid, GLuint list, GLenum mode);
+angle::CallCapture CaptureNormal3b(const State &glState,
+                                   bool isCallValid,
+                                   GLbyte nx,
+                                   GLbyte ny,
+                                   GLbyte nz);
+angle::CallCapture CaptureNormal3bv(const State &glState, bool isCallValid, const GLbyte *v);
+angle::CallCapture CaptureNormal3d(const State &glState,
+                                   bool isCallValid,
+                                   GLdouble nx,
+                                   GLdouble ny,
+                                   GLdouble nz);
+angle::CallCapture CaptureNormal3dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureNormal3fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureNormal3i(const State &glState,
+                                   bool isCallValid,
+                                   GLint nx,
+                                   GLint ny,
+                                   GLint nz);
+angle::CallCapture CaptureNormal3iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureNormal3s(const State &glState,
+                                   bool isCallValid,
+                                   GLshort nx,
+                                   GLshort ny,
+                                   GLshort nz);
+angle::CallCapture CaptureNormal3sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureOrtho(const State &glState,
+                                bool isCallValid,
+                                GLdouble left,
+                                GLdouble right,
+                                GLdouble bottom,
+                                GLdouble top,
+                                GLdouble zNear,
+                                GLdouble zFar);
+angle::CallCapture CapturePassThrough(const State &glState, bool isCallValid, GLfloat token);
+angle::CallCapture CapturePixelMapfv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum map,
+                                     GLsizei mapsize,
+                                     const GLfloat *values);
+angle::CallCapture CapturePixelMapuiv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum map,
+                                      GLsizei mapsize,
+                                      const GLuint *values);
+angle::CallCapture CapturePixelMapusv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum map,
+                                      GLsizei mapsize,
+                                      const GLushort *values);
+angle::CallCapture CapturePixelStoref(const State &glState,
+                                      bool isCallValid,
+                                      GLenum pname,
+                                      GLfloat param);
+angle::CallCapture CapturePixelTransferf(const State &glState,
+                                         bool isCallValid,
+                                         GLenum pname,
+                                         GLfloat param);
+angle::CallCapture CapturePixelTransferi(const State &glState,
+                                         bool isCallValid,
+                                         GLenum pname,
+                                         GLint param);
+angle::CallCapture CapturePixelZoom(const State &glState,
+                                    bool isCallValid,
+                                    GLfloat xfactor,
+                                    GLfloat yfactor);
+angle::CallCapture CapturePolygonMode(const State &glState,
+                                      bool isCallValid,
+                                      GLenum face,
+                                      GLenum mode);
+angle::CallCapture CapturePolygonStipple(const State &glState,
+                                         bool isCallValid,
+                                         const GLubyte *mask);
+angle::CallCapture CapturePopAttrib(const State &glState, bool isCallValid);
+angle::CallCapture CapturePopName(const State &glState, bool isCallValid);
+angle::CallCapture CapturePushAttrib(const State &glState, bool isCallValid, GLbitfield mask);
+angle::CallCapture CapturePushName(const State &glState, bool isCallValid, GLuint name);
+angle::CallCapture CaptureRasterPos2d(const State &glState,
+                                      bool isCallValid,
+                                      GLdouble x,
+                                      GLdouble y);
+angle::CallCapture CaptureRasterPos2dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureRasterPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
+angle::CallCapture CaptureRasterPos2fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureRasterPos2i(const State &glState, bool isCallValid, GLint x, GLint y);
+angle::CallCapture CaptureRasterPos2iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureRasterPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
+angle::CallCapture CaptureRasterPos2sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureRasterPos3d(const State &glState,
+                                      bool isCallValid,
+                                      GLdouble x,
+                                      GLdouble y,
+                                      GLdouble z);
+angle::CallCapture CaptureRasterPos3dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureRasterPos3f(const State &glState,
+                                      bool isCallValid,
+                                      GLfloat x,
+                                      GLfloat y,
+                                      GLfloat z);
+angle::CallCapture CaptureRasterPos3fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureRasterPos3i(const State &glState,
+                                      bool isCallValid,
+                                      GLint x,
+                                      GLint y,
+                                      GLint z);
+angle::CallCapture CaptureRasterPos3iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureRasterPos3s(const State &glState,
+                                      bool isCallValid,
+                                      GLshort x,
+                                      GLshort y,
+                                      GLshort z);
+angle::CallCapture CaptureRasterPos3sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureRasterPos4d(const State &glState,
+                                      bool isCallValid,
+                                      GLdouble x,
+                                      GLdouble y,
+                                      GLdouble z,
+                                      GLdouble w);
+angle::CallCapture CaptureRasterPos4dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureRasterPos4f(const State &glState,
+                                      bool isCallValid,
+                                      GLfloat x,
+                                      GLfloat y,
+                                      GLfloat z,
+                                      GLfloat w);
+angle::CallCapture CaptureRasterPos4fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureRasterPos4i(const State &glState,
+                                      bool isCallValid,
+                                      GLint x,
+                                      GLint y,
+                                      GLint z,
+                                      GLint w);
+angle::CallCapture CaptureRasterPos4iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureRasterPos4s(const State &glState,
+                                      bool isCallValid,
+                                      GLshort x,
+                                      GLshort y,
+                                      GLshort z,
+                                      GLshort w);
+angle::CallCapture CaptureRasterPos4sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureRectd(const State &glState,
+                                bool isCallValid,
+                                GLdouble x1,
+                                GLdouble y1,
+                                GLdouble x2,
+                                GLdouble y2);
+angle::CallCapture CaptureRectdv(const State &glState,
+                                 bool isCallValid,
+                                 const GLdouble *v1,
+                                 const GLdouble *v2);
+angle::CallCapture CaptureRectf(const State &glState,
+                                bool isCallValid,
+                                GLfloat x1,
+                                GLfloat y1,
+                                GLfloat x2,
+                                GLfloat y2);
+angle::CallCapture CaptureRectfv(const State &glState,
+                                 bool isCallValid,
+                                 const GLfloat *v1,
+                                 const GLfloat *v2);
+angle::CallCapture CaptureRecti(const State &glState,
+                                bool isCallValid,
+                                GLint x1,
+                                GLint y1,
+                                GLint x2,
+                                GLint y2);
+angle::CallCapture CaptureRectiv(const State &glState,
+                                 bool isCallValid,
+                                 const GLint *v1,
+                                 const GLint *v2);
+angle::CallCapture CaptureRects(const State &glState,
+                                bool isCallValid,
+                                GLshort x1,
+                                GLshort y1,
+                                GLshort x2,
+                                GLshort y2);
+angle::CallCapture CaptureRectsv(const State &glState,
+                                 bool isCallValid,
+                                 const GLshort *v1,
+                                 const GLshort *v2);
+angle::CallCapture CaptureRenderMode(const State &glState,
+                                     bool isCallValid,
+                                     GLenum mode,
+                                     GLint returnValue);
+angle::CallCapture CaptureRotated(const State &glState,
+                                  bool isCallValid,
+                                  GLdouble angle,
+                                  GLdouble x,
+                                  GLdouble y,
+                                  GLdouble z);
+angle::CallCapture CaptureScaled(const State &glState,
+                                 bool isCallValid,
+                                 GLdouble x,
+                                 GLdouble y,
+                                 GLdouble z);
+angle::CallCapture CaptureSelectBuffer(const State &glState,
+                                       bool isCallValid,
+                                       GLsizei size,
+                                       GLuint *buffer);
+angle::CallCapture CaptureTexCoord1d(const State &glState, bool isCallValid, GLdouble s);
+angle::CallCapture CaptureTexCoord1dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureTexCoord1f(const State &glState, bool isCallValid, GLfloat s);
+angle::CallCapture CaptureTexCoord1fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureTexCoord1i(const State &glState, bool isCallValid, GLint s);
+angle::CallCapture CaptureTexCoord1iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureTexCoord1s(const State &glState, bool isCallValid, GLshort s);
+angle::CallCapture CaptureTexCoord1sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureTexCoord2d(const State &glState,
+                                     bool isCallValid,
+                                     GLdouble s,
+                                     GLdouble t);
+angle::CallCapture CaptureTexCoord2dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureTexCoord2f(const State &glState, bool isCallValid, GLfloat s, GLfloat t);
+angle::CallCapture CaptureTexCoord2fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureTexCoord2i(const State &glState, bool isCallValid, GLint s, GLint t);
+angle::CallCapture CaptureTexCoord2iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureTexCoord2s(const State &glState, bool isCallValid, GLshort s, GLshort t);
+angle::CallCapture CaptureTexCoord2sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureTexCoord3d(const State &glState,
+                                     bool isCallValid,
+                                     GLdouble s,
+                                     GLdouble t,
+                                     GLdouble r);
+angle::CallCapture CaptureTexCoord3dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureTexCoord3f(const State &glState,
+                                     bool isCallValid,
+                                     GLfloat s,
+                                     GLfloat t,
+                                     GLfloat r);
+angle::CallCapture CaptureTexCoord3fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureTexCoord3i(const State &glState,
+                                     bool isCallValid,
+                                     GLint s,
+                                     GLint t,
+                                     GLint r);
+angle::CallCapture CaptureTexCoord3iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureTexCoord3s(const State &glState,
+                                     bool isCallValid,
+                                     GLshort s,
+                                     GLshort t,
+                                     GLshort r);
+angle::CallCapture CaptureTexCoord3sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureTexCoord4d(const State &glState,
+                                     bool isCallValid,
+                                     GLdouble s,
+                                     GLdouble t,
+                                     GLdouble r,
+                                     GLdouble q);
+angle::CallCapture CaptureTexCoord4dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureTexCoord4f(const State &glState,
+                                     bool isCallValid,
+                                     GLfloat s,
+                                     GLfloat t,
+                                     GLfloat r,
+                                     GLfloat q);
+angle::CallCapture CaptureTexCoord4fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureTexCoord4i(const State &glState,
+                                     bool isCallValid,
+                                     GLint s,
+                                     GLint t,
+                                     GLint r,
+                                     GLint q);
+angle::CallCapture CaptureTexCoord4iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureTexCoord4s(const State &glState,
+                                     bool isCallValid,
+                                     GLshort s,
+                                     GLshort t,
+                                     GLshort r,
+                                     GLshort q);
+angle::CallCapture CaptureTexCoord4sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureTexGend(const State &glState,
+                                  bool isCallValid,
+                                  GLenum coord,
+                                  GLenum pname,
+                                  GLdouble param);
+angle::CallCapture CaptureTexGendv(const State &glState,
+                                   bool isCallValid,
+                                   GLenum coord,
+                                   GLenum pname,
+                                   const GLdouble *params);
+angle::CallCapture CaptureTexGenf(const State &glState,
+                                  bool isCallValid,
+                                  GLenum coord,
+                                  GLenum pname,
+                                  GLfloat param);
+angle::CallCapture CaptureTexGenfv(const State &glState,
+                                   bool isCallValid,
+                                   GLenum coord,
+                                   GLenum pname,
+                                   const GLfloat *params);
+angle::CallCapture CaptureTexGeni(const State &glState,
+                                  bool isCallValid,
+                                  GLenum coord,
+                                  GLenum pname,
+                                  GLint param);
+angle::CallCapture CaptureTexGeniv(const State &glState,
+                                   bool isCallValid,
+                                   GLenum coord,
+                                   GLenum pname,
+                                   const GLint *params);
+angle::CallCapture CaptureTexImage1D(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLint level,
+                                     GLint internalformat,
+                                     GLsizei width,
+                                     GLint border,
+                                     GLenum format,
+                                     GLenum type,
+                                     const void *pixels);
+angle::CallCapture CaptureTranslated(const State &glState,
+                                     bool isCallValid,
+                                     GLdouble x,
+                                     GLdouble y,
+                                     GLdouble z);
+angle::CallCapture CaptureVertex2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y);
+angle::CallCapture CaptureVertex2dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureVertex2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
+angle::CallCapture CaptureVertex2fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureVertex2i(const State &glState, bool isCallValid, GLint x, GLint y);
+angle::CallCapture CaptureVertex2iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureVertex2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
+angle::CallCapture CaptureVertex2sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureVertex3d(const State &glState,
+                                   bool isCallValid,
+                                   GLdouble x,
+                                   GLdouble y,
+                                   GLdouble z);
+angle::CallCapture CaptureVertex3dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureVertex3f(const State &glState,
+                                   bool isCallValid,
+                                   GLfloat x,
+                                   GLfloat y,
+                                   GLfloat z);
+angle::CallCapture CaptureVertex3fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureVertex3i(const State &glState,
+                                   bool isCallValid,
+                                   GLint x,
+                                   GLint y,
+                                   GLint z);
+angle::CallCapture CaptureVertex3iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureVertex3s(const State &glState,
+                                   bool isCallValid,
+                                   GLshort x,
+                                   GLshort y,
+                                   GLshort z);
+angle::CallCapture CaptureVertex3sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureVertex4d(const State &glState,
+                                   bool isCallValid,
+                                   GLdouble x,
+                                   GLdouble y,
+                                   GLdouble z,
+                                   GLdouble w);
+angle::CallCapture CaptureVertex4dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureVertex4f(const State &glState,
+                                   bool isCallValid,
+                                   GLfloat x,
+                                   GLfloat y,
+                                   GLfloat z,
+                                   GLfloat w);
+angle::CallCapture CaptureVertex4fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureVertex4i(const State &glState,
+                                   bool isCallValid,
+                                   GLint x,
+                                   GLint y,
+                                   GLint z,
+                                   GLint w);
+angle::CallCapture CaptureVertex4iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureVertex4s(const State &glState,
+                                   bool isCallValid,
+                                   GLshort x,
+                                   GLshort y,
+                                   GLshort z,
+                                   GLshort w);
+angle::CallCapture CaptureVertex4sv(const State &glState, bool isCallValid, const GLshort *v);
+
+// GL 1.1
+angle::CallCapture CaptureAreTexturesResident(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              const GLuint *textures,
+                                              GLboolean *residences,
+                                              GLboolean returnValue);
+angle::CallCapture CaptureArrayElement(const State &glState, bool isCallValid, GLint i);
+angle::CallCapture CaptureCopyTexImage1D(const State &glState,
+                                         bool isCallValid,
+                                         GLenum target,
+                                         GLint level,
+                                         GLenum internalformat,
+                                         GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLint border);
+angle::CallCapture CaptureCopyTexSubImage1D(const State &glState,
+                                            bool isCallValid,
+                                            GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint x,
+                                            GLint y,
+                                            GLsizei width);
+angle::CallCapture CaptureEdgeFlagPointer(const State &glState,
+                                          bool isCallValid,
+                                          GLsizei stride,
+                                          const void *pointer);
+angle::CallCapture CaptureIndexPointer(const State &glState,
+                                       bool isCallValid,
+                                       GLenum type,
+                                       GLsizei stride,
+                                       const void *pointer);
+angle::CallCapture CaptureIndexub(const State &glState, bool isCallValid, GLubyte c);
+angle::CallCapture CaptureIndexubv(const State &glState, bool isCallValid, const GLubyte *c);
+angle::CallCapture CaptureInterleavedArrays(const State &glState,
+                                            bool isCallValid,
+                                            GLenum format,
+                                            GLsizei stride,
+                                            const void *pointer);
+angle::CallCapture CapturePopClientAttrib(const State &glState, bool isCallValid);
+angle::CallCapture CapturePrioritizeTextures(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             const GLuint *textures,
+                                             const GLfloat *priorities);
+angle::CallCapture CapturePushClientAttrib(const State &glState, bool isCallValid, GLbitfield mask);
+angle::CallCapture CaptureTexSubImage1D(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLint level,
+                                        GLint xoffset,
+                                        GLsizei width,
+                                        GLenum format,
+                                        GLenum type,
+                                        const void *pixels);
+
+// GL 1.2
+
+// GL 1.3
+angle::CallCapture CaptureCompressedTexImage1D(const State &glState,
+                                               bool isCallValid,
+                                               GLenum target,
+                                               GLint level,
+                                               GLenum internalformat,
+                                               GLsizei width,
+                                               GLint border,
+                                               GLsizei imageSize,
+                                               const void *data);
+angle::CallCapture CaptureCompressedTexSubImage1D(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum target,
+                                                  GLint level,
+                                                  GLint xoffset,
+                                                  GLsizei width,
+                                                  GLenum format,
+                                                  GLsizei imageSize,
+                                                  const void *data);
+angle::CallCapture CaptureGetCompressedTexImage(const State &glState,
+                                                bool isCallValid,
+                                                TextureTarget targetPacked,
+                                                GLint level,
+                                                void *img);
+angle::CallCapture CaptureLoadTransposeMatrixd(const State &glState,
+                                               bool isCallValid,
+                                               const GLdouble *m);
+angle::CallCapture CaptureLoadTransposeMatrixf(const State &glState,
+                                               bool isCallValid,
+                                               const GLfloat *m);
+angle::CallCapture CaptureMultTransposeMatrixd(const State &glState,
+                                               bool isCallValid,
+                                               const GLdouble *m);
+angle::CallCapture CaptureMultTransposeMatrixf(const State &glState,
+                                               bool isCallValid,
+                                               const GLfloat *m);
+angle::CallCapture CaptureMultiTexCoord1d(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLdouble s);
+angle::CallCapture CaptureMultiTexCoord1dv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLdouble *v);
+angle::CallCapture CaptureMultiTexCoord1f(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLfloat s);
+angle::CallCapture CaptureMultiTexCoord1fv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLfloat *v);
+angle::CallCapture CaptureMultiTexCoord1i(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLint s);
+angle::CallCapture CaptureMultiTexCoord1iv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLint *v);
+angle::CallCapture CaptureMultiTexCoord1s(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLshort s);
+angle::CallCapture CaptureMultiTexCoord1sv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLshort *v);
+angle::CallCapture CaptureMultiTexCoord2d(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLdouble s,
+                                          GLdouble t);
+angle::CallCapture CaptureMultiTexCoord2dv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLdouble *v);
+angle::CallCapture CaptureMultiTexCoord2f(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLfloat s,
+                                          GLfloat t);
+angle::CallCapture CaptureMultiTexCoord2fv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLfloat *v);
+angle::CallCapture CaptureMultiTexCoord2i(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLint s,
+                                          GLint t);
+angle::CallCapture CaptureMultiTexCoord2iv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLint *v);
+angle::CallCapture CaptureMultiTexCoord2s(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLshort s,
+                                          GLshort t);
+angle::CallCapture CaptureMultiTexCoord2sv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLshort *v);
+angle::CallCapture CaptureMultiTexCoord3d(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLdouble s,
+                                          GLdouble t,
+                                          GLdouble r);
+angle::CallCapture CaptureMultiTexCoord3dv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLdouble *v);
+angle::CallCapture CaptureMultiTexCoord3f(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLfloat s,
+                                          GLfloat t,
+                                          GLfloat r);
+angle::CallCapture CaptureMultiTexCoord3fv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLfloat *v);
+angle::CallCapture CaptureMultiTexCoord3i(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLint s,
+                                          GLint t,
+                                          GLint r);
+angle::CallCapture CaptureMultiTexCoord3iv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLint *v);
+angle::CallCapture CaptureMultiTexCoord3s(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLshort s,
+                                          GLshort t,
+                                          GLshort r);
+angle::CallCapture CaptureMultiTexCoord3sv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLshort *v);
+angle::CallCapture CaptureMultiTexCoord4d(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLdouble s,
+                                          GLdouble t,
+                                          GLdouble r,
+                                          GLdouble q);
+angle::CallCapture CaptureMultiTexCoord4dv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLdouble *v);
+angle::CallCapture CaptureMultiTexCoord4fv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLfloat *v);
+angle::CallCapture CaptureMultiTexCoord4i(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLint s,
+                                          GLint t,
+                                          GLint r,
+                                          GLint q);
+angle::CallCapture CaptureMultiTexCoord4iv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLint *v);
+angle::CallCapture CaptureMultiTexCoord4s(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLshort s,
+                                          GLshort t,
+                                          GLshort r,
+                                          GLshort q);
+angle::CallCapture CaptureMultiTexCoord4sv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           const GLshort *v);
+
+// GL 1.4
+angle::CallCapture CaptureFogCoordPointer(const State &glState,
+                                          bool isCallValid,
+                                          GLenum type,
+                                          GLsizei stride,
+                                          const void *pointer);
+angle::CallCapture CaptureFogCoordd(const State &glState, bool isCallValid, GLdouble coord);
+angle::CallCapture CaptureFogCoorddv(const State &glState, bool isCallValid, const GLdouble *coord);
+angle::CallCapture CaptureFogCoordf(const State &glState, bool isCallValid, GLfloat coord);
+angle::CallCapture CaptureFogCoordfv(const State &glState, bool isCallValid, const GLfloat *coord);
+angle::CallCapture CaptureMultiDrawArrays(const State &glState,
+                                          bool isCallValid,
+                                          PrimitiveMode modePacked,
+                                          const GLint *first,
+                                          const GLsizei *count,
+                                          GLsizei drawcount);
+angle::CallCapture CaptureMultiDrawElements(const State &glState,
+                                            bool isCallValid,
+                                            PrimitiveMode modePacked,
+                                            const GLsizei *count,
+                                            DrawElementsType typePacked,
+                                            const void *const *indices,
+                                            GLsizei drawcount);
+angle::CallCapture CapturePointParameteri(const State &glState,
+                                          bool isCallValid,
+                                          GLenum pname,
+                                          GLint param);
+angle::CallCapture CapturePointParameteriv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum pname,
+                                           const GLint *params);
+angle::CallCapture CaptureSecondaryColor3b(const State &glState,
+                                           bool isCallValid,
+                                           GLbyte red,
+                                           GLbyte green,
+                                           GLbyte blue);
+angle::CallCapture CaptureSecondaryColor3bv(const State &glState,
+                                            bool isCallValid,
+                                            const GLbyte *v);
+angle::CallCapture CaptureSecondaryColor3d(const State &glState,
+                                           bool isCallValid,
+                                           GLdouble red,
+                                           GLdouble green,
+                                           GLdouble blue);
+angle::CallCapture CaptureSecondaryColor3dv(const State &glState,
+                                            bool isCallValid,
+                                            const GLdouble *v);
+angle::CallCapture CaptureSecondaryColor3f(const State &glState,
+                                           bool isCallValid,
+                                           GLfloat red,
+                                           GLfloat green,
+                                           GLfloat blue);
+angle::CallCapture CaptureSecondaryColor3fv(const State &glState,
+                                            bool isCallValid,
+                                            const GLfloat *v);
+angle::CallCapture CaptureSecondaryColor3i(const State &glState,
+                                           bool isCallValid,
+                                           GLint red,
+                                           GLint green,
+                                           GLint blue);
+angle::CallCapture CaptureSecondaryColor3iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureSecondaryColor3s(const State &glState,
+                                           bool isCallValid,
+                                           GLshort red,
+                                           GLshort green,
+                                           GLshort blue);
+angle::CallCapture CaptureSecondaryColor3sv(const State &glState,
+                                            bool isCallValid,
+                                            const GLshort *v);
+angle::CallCapture CaptureSecondaryColor3ub(const State &glState,
+                                            bool isCallValid,
+                                            GLubyte red,
+                                            GLubyte green,
+                                            GLubyte blue);
+angle::CallCapture CaptureSecondaryColor3ubv(const State &glState,
+                                             bool isCallValid,
+                                             const GLubyte *v);
+angle::CallCapture CaptureSecondaryColor3ui(const State &glState,
+                                            bool isCallValid,
+                                            GLuint red,
+                                            GLuint green,
+                                            GLuint blue);
+angle::CallCapture CaptureSecondaryColor3uiv(const State &glState,
+                                             bool isCallValid,
+                                             const GLuint *v);
+angle::CallCapture CaptureSecondaryColor3us(const State &glState,
+                                            bool isCallValid,
+                                            GLushort red,
+                                            GLushort green,
+                                            GLushort blue);
+angle::CallCapture CaptureSecondaryColor3usv(const State &glState,
+                                             bool isCallValid,
+                                             const GLushort *v);
+angle::CallCapture CaptureSecondaryColorPointer(const State &glState,
+                                                bool isCallValid,
+                                                GLint size,
+                                                GLenum type,
+                                                GLsizei stride,
+                                                const void *pointer);
+angle::CallCapture CaptureWindowPos2d(const State &glState,
+                                      bool isCallValid,
+                                      GLdouble x,
+                                      GLdouble y);
+angle::CallCapture CaptureWindowPos2dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureWindowPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y);
+angle::CallCapture CaptureWindowPos2fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureWindowPos2i(const State &glState, bool isCallValid, GLint x, GLint y);
+angle::CallCapture CaptureWindowPos2iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureWindowPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y);
+angle::CallCapture CaptureWindowPos2sv(const State &glState, bool isCallValid, const GLshort *v);
+angle::CallCapture CaptureWindowPos3d(const State &glState,
+                                      bool isCallValid,
+                                      GLdouble x,
+                                      GLdouble y,
+                                      GLdouble z);
+angle::CallCapture CaptureWindowPos3dv(const State &glState, bool isCallValid, const GLdouble *v);
+angle::CallCapture CaptureWindowPos3f(const State &glState,
+                                      bool isCallValid,
+                                      GLfloat x,
+                                      GLfloat y,
+                                      GLfloat z);
+angle::CallCapture CaptureWindowPos3fv(const State &glState, bool isCallValid, const GLfloat *v);
+angle::CallCapture CaptureWindowPos3i(const State &glState,
+                                      bool isCallValid,
+                                      GLint x,
+                                      GLint y,
+                                      GLint z);
+angle::CallCapture CaptureWindowPos3iv(const State &glState, bool isCallValid, const GLint *v);
+angle::CallCapture CaptureWindowPos3s(const State &glState,
+                                      bool isCallValid,
+                                      GLshort x,
+                                      GLshort y,
+                                      GLshort z);
+angle::CallCapture CaptureWindowPos3sv(const State &glState, bool isCallValid, const GLshort *v);
+
+// GL 1.5
+angle::CallCapture CaptureGetBufferSubData(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           GLintptr offset,
+                                           GLsizeiptr size,
+                                           void *data);
+angle::CallCapture CaptureGetQueryObjectiv(const State &glState,
+                                           bool isCallValid,
+                                           QueryID idPacked,
+                                           GLenum pname,
+                                           GLint *params);
+angle::CallCapture CaptureMapBuffer(const State &glState,
+                                    bool isCallValid,
+                                    BufferBinding targetPacked,
+                                    GLenum access,
+                                    void *returnValue);
+
+// Parameter Captures
+
+// GL 1.0
+void CaptureBitmap_bitmap(const State &glState,
+                          bool isCallValid,
+                          GLsizei width,
+                          GLsizei height,
+                          GLfloat xorig,
+                          GLfloat yorig,
+                          GLfloat xmove,
+                          GLfloat ymove,
+                          const GLubyte *bitmap,
+                          angle::ParamCapture *paramCapture);
+void CaptureCallLists_lists(const State &glState,
+                            bool isCallValid,
+                            GLsizei n,
+                            GLenum type,
+                            const void *lists,
+                            angle::ParamCapture *paramCapture);
+void CaptureClipPlane_equation(const State &glState,
+                               bool isCallValid,
+                               GLenum plane,
+                               const GLdouble *equation,
+                               angle::ParamCapture *paramCapture);
+void CaptureColor3bv_v(const State &glState,
+                       bool isCallValid,
+                       const GLbyte *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor3dv_v(const State &glState,
+                       bool isCallValid,
+                       const GLdouble *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor3fv_v(const State &glState,
+                       bool isCallValid,
+                       const GLfloat *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor3iv_v(const State &glState,
+                       bool isCallValid,
+                       const GLint *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor3sv_v(const State &glState,
+                       bool isCallValid,
+                       const GLshort *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor3ubv_v(const State &glState,
+                        bool isCallValid,
+                        const GLubyte *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureColor3uiv_v(const State &glState,
+                        bool isCallValid,
+                        const GLuint *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureColor3usv_v(const State &glState,
+                        bool isCallValid,
+                        const GLushort *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureColor4bv_v(const State &glState,
+                       bool isCallValid,
+                       const GLbyte *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor4dv_v(const State &glState,
+                       bool isCallValid,
+                       const GLdouble *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor4fv_v(const State &glState,
+                       bool isCallValid,
+                       const GLfloat *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor4iv_v(const State &glState,
+                       bool isCallValid,
+                       const GLint *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor4sv_v(const State &glState,
+                       bool isCallValid,
+                       const GLshort *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureColor4ubv_v(const State &glState,
+                        bool isCallValid,
+                        const GLubyte *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureColor4uiv_v(const State &glState,
+                        bool isCallValid,
+                        const GLuint *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureColor4usv_v(const State &glState,
+                        bool isCallValid,
+                        const GLushort *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureDrawPixels_pixels(const State &glState,
+                              bool isCallValid,
+                              GLsizei width,
+                              GLsizei height,
+                              GLenum format,
+                              GLenum type,
+                              const void *pixels,
+                              angle::ParamCapture *paramCapture);
+void CaptureEdgeFlagv_flag(const State &glState,
+                           bool isCallValid,
+                           const GLboolean *flag,
+                           angle::ParamCapture *paramCapture);
+void CaptureEvalCoord1dv_u(const State &glState,
+                           bool isCallValid,
+                           const GLdouble *u,
+                           angle::ParamCapture *paramCapture);
+void CaptureEvalCoord1fv_u(const State &glState,
+                           bool isCallValid,
+                           const GLfloat *u,
+                           angle::ParamCapture *paramCapture);
+void CaptureEvalCoord2dv_u(const State &glState,
+                           bool isCallValid,
+                           const GLdouble *u,
+                           angle::ParamCapture *paramCapture);
+void CaptureEvalCoord2fv_u(const State &glState,
+                           bool isCallValid,
+                           const GLfloat *u,
+                           angle::ParamCapture *paramCapture);
+void CaptureFeedbackBuffer_buffer(const State &glState,
+                                  bool isCallValid,
+                                  GLsizei size,
+                                  GLenum type,
+                                  GLfloat *buffer,
+                                  angle::ParamCapture *paramCapture);
+void CaptureFogiv_params(const State &glState,
+                         bool isCallValid,
+                         GLenum pname,
+                         const GLint *params,
+                         angle::ParamCapture *paramCapture);
+void CaptureGetClipPlane_equation(const State &glState,
+                                  bool isCallValid,
+                                  GLenum plane,
+                                  GLdouble *equation,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetDoublev_data(const State &glState,
+                            bool isCallValid,
+                            GLenum pname,
+                            GLdouble *data,
+                            angle::ParamCapture *paramCapture);
+void CaptureGetLightiv_params(const State &glState,
+                              bool isCallValid,
+                              GLenum light,
+                              GLenum pname,
+                              GLint *params,
+                              angle::ParamCapture *paramCapture);
+void CaptureGetMapdv_v(const State &glState,
+                       bool isCallValid,
+                       GLenum target,
+                       GLenum query,
+                       GLdouble *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureGetMapfv_v(const State &glState,
+                       bool isCallValid,
+                       GLenum target,
+                       GLenum query,
+                       GLfloat *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureGetMapiv_v(const State &glState,
+                       bool isCallValid,
+                       GLenum target,
+                       GLenum query,
+                       GLint *v,
+                       angle::ParamCapture *paramCapture);
+void CaptureGetMaterialiv_params(const State &glState,
+                                 bool isCallValid,
+                                 GLenum face,
+                                 GLenum pname,
+                                 GLint *params,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetPixelMapfv_values(const State &glState,
+                                 bool isCallValid,
+                                 GLenum map,
+                                 GLfloat *values,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetPixelMapuiv_values(const State &glState,
+                                  bool isCallValid,
+                                  GLenum map,
+                                  GLuint *values,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetPixelMapusv_values(const State &glState,
+                                  bool isCallValid,
+                                  GLenum map,
+                                  GLushort *values,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetPolygonStipple_mask(const State &glState,
+                                   bool isCallValid,
+                                   GLubyte *mask,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetTexGendv_params(const State &glState,
+                               bool isCallValid,
+                               GLenum coord,
+                               GLenum pname,
+                               GLdouble *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetTexGenfv_params(const State &glState,
+                               bool isCallValid,
+                               GLenum coord,
+                               GLenum pname,
+                               GLfloat *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetTexGeniv_params(const State &glState,
+                               bool isCallValid,
+                               GLenum coord,
+                               GLenum pname,
+                               GLint *params,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetTexImage_pixels(const State &glState,
+                               bool isCallValid,
+                               TextureTarget targetPacked,
+                               GLint level,
+                               GLenum format,
+                               GLenum type,
+                               void *pixels,
+                               angle::ParamCapture *paramCapture);
+void CaptureIndexdv_c(const State &glState,
+                      bool isCallValid,
+                      const GLdouble *c,
+                      angle::ParamCapture *paramCapture);
+void CaptureIndexfv_c(const State &glState,
+                      bool isCallValid,
+                      const GLfloat *c,
+                      angle::ParamCapture *paramCapture);
+void CaptureIndexiv_c(const State &glState,
+                      bool isCallValid,
+                      const GLint *c,
+                      angle::ParamCapture *paramCapture);
+void CaptureIndexsv_c(const State &glState,
+                      bool isCallValid,
+                      const GLshort *c,
+                      angle::ParamCapture *paramCapture);
+void CaptureLightModeliv_params(const State &glState,
+                                bool isCallValid,
+                                GLenum pname,
+                                const GLint *params,
+                                angle::ParamCapture *paramCapture);
+void CaptureLightiv_params(const State &glState,
+                           bool isCallValid,
+                           GLenum light,
+                           GLenum pname,
+                           const GLint *params,
+                           angle::ParamCapture *paramCapture);
+void CaptureLoadMatrixd_m(const State &glState,
+                          bool isCallValid,
+                          const GLdouble *m,
+                          angle::ParamCapture *paramCapture);
+void CaptureMap1d_points(const State &glState,
+                         bool isCallValid,
+                         GLenum target,
+                         GLdouble u1,
+                         GLdouble u2,
+                         GLint stride,
+                         GLint order,
+                         const GLdouble *points,
+                         angle::ParamCapture *paramCapture);
+void CaptureMap1f_points(const State &glState,
+                         bool isCallValid,
+                         GLenum target,
+                         GLfloat u1,
+                         GLfloat u2,
+                         GLint stride,
+                         GLint order,
+                         const GLfloat *points,
+                         angle::ParamCapture *paramCapture);
+void CaptureMap2d_points(const State &glState,
+                         bool isCallValid,
+                         GLenum target,
+                         GLdouble u1,
+                         GLdouble u2,
+                         GLint ustride,
+                         GLint uorder,
+                         GLdouble v1,
+                         GLdouble v2,
+                         GLint vstride,
+                         GLint vorder,
+                         const GLdouble *points,
+                         angle::ParamCapture *paramCapture);
+void CaptureMap2f_points(const State &glState,
+                         bool isCallValid,
+                         GLenum target,
+                         GLfloat u1,
+                         GLfloat u2,
+                         GLint ustride,
+                         GLint uorder,
+                         GLfloat v1,
+                         GLfloat v2,
+                         GLint vstride,
+                         GLint vorder,
+                         const GLfloat *points,
+                         angle::ParamCapture *paramCapture);
+void CaptureMaterialiv_params(const State &glState,
+                              bool isCallValid,
+                              GLenum face,
+                              GLenum pname,
+                              const GLint *params,
+                              angle::ParamCapture *paramCapture);
+void CaptureMultMatrixd_m(const State &glState,
+                          bool isCallValid,
+                          const GLdouble *m,
+                          angle::ParamCapture *paramCapture);
+void CaptureNormal3bv_v(const State &glState,
+                        bool isCallValid,
+                        const GLbyte *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureNormal3dv_v(const State &glState,
+                        bool isCallValid,
+                        const GLdouble *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureNormal3fv_v(const State &glState,
+                        bool isCallValid,
+                        const GLfloat *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureNormal3iv_v(const State &glState,
+                        bool isCallValid,
+                        const GLint *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureNormal3sv_v(const State &glState,
+                        bool isCallValid,
+                        const GLshort *v,
+                        angle::ParamCapture *paramCapture);
+void CapturePixelMapfv_values(const State &glState,
+                              bool isCallValid,
+                              GLenum map,
+                              GLsizei mapsize,
+                              const GLfloat *values,
+                              angle::ParamCapture *paramCapture);
+void CapturePixelMapuiv_values(const State &glState,
+                               bool isCallValid,
+                               GLenum map,
+                               GLsizei mapsize,
+                               const GLuint *values,
+                               angle::ParamCapture *paramCapture);
+void CapturePixelMapusv_values(const State &glState,
+                               bool isCallValid,
+                               GLenum map,
+                               GLsizei mapsize,
+                               const GLushort *values,
+                               angle::ParamCapture *paramCapture);
+void CapturePolygonStipple_mask(const State &glState,
+                                bool isCallValid,
+                                const GLubyte *mask,
+                                angle::ParamCapture *paramCapture);
+void CaptureRasterPos2dv_v(const State &glState,
+                           bool isCallValid,
+                           const GLdouble *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos2fv_v(const State &glState,
+                           bool isCallValid,
+                           const GLfloat *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos2iv_v(const State &glState,
+                           bool isCallValid,
+                           const GLint *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos2sv_v(const State &glState,
+                           bool isCallValid,
+                           const GLshort *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos3dv_v(const State &glState,
+                           bool isCallValid,
+                           const GLdouble *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos3fv_v(const State &glState,
+                           bool isCallValid,
+                           const GLfloat *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos3iv_v(const State &glState,
+                           bool isCallValid,
+                           const GLint *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos3sv_v(const State &glState,
+                           bool isCallValid,
+                           const GLshort *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos4dv_v(const State &glState,
+                           bool isCallValid,
+                           const GLdouble *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos4fv_v(const State &glState,
+                           bool isCallValid,
+                           const GLfloat *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos4iv_v(const State &glState,
+                           bool isCallValid,
+                           const GLint *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRasterPos4sv_v(const State &glState,
+                           bool isCallValid,
+                           const GLshort *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureRectdv_v1(const State &glState,
+                      bool isCallValid,
+                      const GLdouble *v1,
+                      const GLdouble *v2,
+                      angle::ParamCapture *paramCapture);
+void CaptureRectdv_v2(const State &glState,
+                      bool isCallValid,
+                      const GLdouble *v1,
+                      const GLdouble *v2,
+                      angle::ParamCapture *paramCapture);
+void CaptureRectfv_v1(const State &glState,
+                      bool isCallValid,
+                      const GLfloat *v1,
+                      const GLfloat *v2,
+                      angle::ParamCapture *paramCapture);
+void CaptureRectfv_v2(const State &glState,
+                      bool isCallValid,
+                      const GLfloat *v1,
+                      const GLfloat *v2,
+                      angle::ParamCapture *paramCapture);
+void CaptureRectiv_v1(const State &glState,
+                      bool isCallValid,
+                      const GLint *v1,
+                      const GLint *v2,
+                      angle::ParamCapture *paramCapture);
+void CaptureRectiv_v2(const State &glState,
+                      bool isCallValid,
+                      const GLint *v1,
+                      const GLint *v2,
+                      angle::ParamCapture *paramCapture);
+void CaptureRectsv_v1(const State &glState,
+                      bool isCallValid,
+                      const GLshort *v1,
+                      const GLshort *v2,
+                      angle::ParamCapture *paramCapture);
+void CaptureRectsv_v2(const State &glState,
+                      bool isCallValid,
+                      const GLshort *v1,
+                      const GLshort *v2,
+                      angle::ParamCapture *paramCapture);
+void CaptureSelectBuffer_buffer(const State &glState,
+                                bool isCallValid,
+                                GLsizei size,
+                                GLuint *buffer,
+                                angle::ParamCapture *paramCapture);
+void CaptureTexCoord1dv_v(const State &glState,
+                          bool isCallValid,
+                          const GLdouble *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord1fv_v(const State &glState,
+                          bool isCallValid,
+                          const GLfloat *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord1iv_v(const State &glState,
+                          bool isCallValid,
+                          const GLint *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord1sv_v(const State &glState,
+                          bool isCallValid,
+                          const GLshort *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord2dv_v(const State &glState,
+                          bool isCallValid,
+                          const GLdouble *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord2fv_v(const State &glState,
+                          bool isCallValid,
+                          const GLfloat *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord2iv_v(const State &glState,
+                          bool isCallValid,
+                          const GLint *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord2sv_v(const State &glState,
+                          bool isCallValid,
+                          const GLshort *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord3dv_v(const State &glState,
+                          bool isCallValid,
+                          const GLdouble *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord3fv_v(const State &glState,
+                          bool isCallValid,
+                          const GLfloat *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord3iv_v(const State &glState,
+                          bool isCallValid,
+                          const GLint *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord3sv_v(const State &glState,
+                          bool isCallValid,
+                          const GLshort *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord4dv_v(const State &glState,
+                          bool isCallValid,
+                          const GLdouble *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord4fv_v(const State &glState,
+                          bool isCallValid,
+                          const GLfloat *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord4iv_v(const State &glState,
+                          bool isCallValid,
+                          const GLint *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexCoord4sv_v(const State &glState,
+                          bool isCallValid,
+                          const GLshort *v,
+                          angle::ParamCapture *paramCapture);
+void CaptureTexGendv_params(const State &glState,
+                            bool isCallValid,
+                            GLenum coord,
+                            GLenum pname,
+                            const GLdouble *params,
+                            angle::ParamCapture *paramCapture);
+void CaptureTexGenfv_params(const State &glState,
+                            bool isCallValid,
+                            GLenum coord,
+                            GLenum pname,
+                            const GLfloat *params,
+                            angle::ParamCapture *paramCapture);
+void CaptureTexGeniv_params(const State &glState,
+                            bool isCallValid,
+                            GLenum coord,
+                            GLenum pname,
+                            const GLint *params,
+                            angle::ParamCapture *paramCapture);
+void CaptureTexImage1D_pixels(const State &glState,
+                              bool isCallValid,
+                              GLenum target,
+                              GLint level,
+                              GLint internalformat,
+                              GLsizei width,
+                              GLint border,
+                              GLenum format,
+                              GLenum type,
+                              const void *pixels,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertex2dv_v(const State &glState,
+                        bool isCallValid,
+                        const GLdouble *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex2fv_v(const State &glState,
+                        bool isCallValid,
+                        const GLfloat *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex2iv_v(const State &glState,
+                        bool isCallValid,
+                        const GLint *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex2sv_v(const State &glState,
+                        bool isCallValid,
+                        const GLshort *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex3dv_v(const State &glState,
+                        bool isCallValid,
+                        const GLdouble *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex3fv_v(const State &glState,
+                        bool isCallValid,
+                        const GLfloat *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex3iv_v(const State &glState,
+                        bool isCallValid,
+                        const GLint *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex3sv_v(const State &glState,
+                        bool isCallValid,
+                        const GLshort *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex4dv_v(const State &glState,
+                        bool isCallValid,
+                        const GLdouble *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex4fv_v(const State &glState,
+                        bool isCallValid,
+                        const GLfloat *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex4iv_v(const State &glState,
+                        bool isCallValid,
+                        const GLint *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureVertex4sv_v(const State &glState,
+                        bool isCallValid,
+                        const GLshort *v,
+                        angle::ParamCapture *paramCapture);
+
+// GL 1.1
+void CaptureAreTexturesResident_textures(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei n,
+                                         const GLuint *textures,
+                                         GLboolean *residences,
+                                         angle::ParamCapture *paramCapture);
+void CaptureAreTexturesResident_residences(const State &glState,
+                                           bool isCallValid,
+                                           GLsizei n,
+                                           const GLuint *textures,
+                                           GLboolean *residences,
+                                           angle::ParamCapture *paramCapture);
+void CaptureEdgeFlagPointer_pointer(const State &glState,
+                                    bool isCallValid,
+                                    GLsizei stride,
+                                    const void *pointer,
+                                    angle::ParamCapture *paramCapture);
+void CaptureIndexPointer_pointer(const State &glState,
+                                 bool isCallValid,
+                                 GLenum type,
+                                 GLsizei stride,
+                                 const void *pointer,
+                                 angle::ParamCapture *paramCapture);
+void CaptureIndexubv_c(const State &glState,
+                       bool isCallValid,
+                       const GLubyte *c,
+                       angle::ParamCapture *paramCapture);
+void CaptureInterleavedArrays_pointer(const State &glState,
+                                      bool isCallValid,
+                                      GLenum format,
+                                      GLsizei stride,
+                                      const void *pointer,
+                                      angle::ParamCapture *paramCapture);
+void CapturePrioritizeTextures_textures(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        const GLuint *textures,
+                                        const GLfloat *priorities,
+                                        angle::ParamCapture *paramCapture);
+void CapturePrioritizeTextures_priorities(const State &glState,
+                                          bool isCallValid,
+                                          GLsizei n,
+                                          const GLuint *textures,
+                                          const GLfloat *priorities,
+                                          angle::ParamCapture *paramCapture);
+void CaptureTexSubImage1D_pixels(const State &glState,
+                                 bool isCallValid,
+                                 GLenum target,
+                                 GLint level,
+                                 GLint xoffset,
+                                 GLsizei width,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void *pixels,
+                                 angle::ParamCapture *paramCapture);
+
+// GL 1.2
+
+// GL 1.3
+void CaptureCompressedTexImage1D_data(const State &glState,
+                                      bool isCallValid,
+                                      GLenum target,
+                                      GLint level,
+                                      GLenum internalformat,
+                                      GLsizei width,
+                                      GLint border,
+                                      GLsizei imageSize,
+                                      const void *data,
+                                      angle::ParamCapture *paramCapture);
+void CaptureCompressedTexSubImage1D_data(const State &glState,
+                                         bool isCallValid,
+                                         GLenum target,
+                                         GLint level,
+                                         GLint xoffset,
+                                         GLsizei width,
+                                         GLenum format,
+                                         GLsizei imageSize,
+                                         const void *data,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetCompressedTexImage_img(const State &glState,
+                                      bool isCallValid,
+                                      TextureTarget targetPacked,
+                                      GLint level,
+                                      void *img,
+                                      angle::ParamCapture *paramCapture);
+void CaptureLoadTransposeMatrixd_m(const State &glState,
+                                   bool isCallValid,
+                                   const GLdouble *m,
+                                   angle::ParamCapture *paramCapture);
+void CaptureLoadTransposeMatrixf_m(const State &glState,
+                                   bool isCallValid,
+                                   const GLfloat *m,
+                                   angle::ParamCapture *paramCapture);
+void CaptureMultTransposeMatrixd_m(const State &glState,
+                                   bool isCallValid,
+                                   const GLdouble *m,
+                                   angle::ParamCapture *paramCapture);
+void CaptureMultTransposeMatrixf_m(const State &glState,
+                                   bool isCallValid,
+                                   const GLfloat *m,
+                                   angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord1dv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord1fv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLfloat *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord1iv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord1sv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLshort *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord2dv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord2fv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLfloat *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord2iv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord2sv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLshort *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord3dv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord3fv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLfloat *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord3iv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord3sv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLshort *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord4dv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord4fv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLfloat *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord4iv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoord4sv_v(const State &glState,
+                               bool isCallValid,
+                               GLenum target,
+                               const GLshort *v,
+                               angle::ParamCapture *paramCapture);
+
+// GL 1.4
+void CaptureFogCoordPointer_pointer(const State &glState,
+                                    bool isCallValid,
+                                    GLenum type,
+                                    GLsizei stride,
+                                    const void *pointer,
+                                    angle::ParamCapture *paramCapture);
+void CaptureFogCoorddv_coord(const State &glState,
+                             bool isCallValid,
+                             const GLdouble *coord,
+                             angle::ParamCapture *paramCapture);
+void CaptureFogCoordfv_coord(const State &glState,
+                             bool isCallValid,
+                             const GLfloat *coord,
+                             angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArrays_first(const State &glState,
+                                  bool isCallValid,
+                                  PrimitiveMode modePacked,
+                                  const GLint *first,
+                                  const GLsizei *count,
+                                  GLsizei drawcount,
+                                  angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArrays_count(const State &glState,
+                                  bool isCallValid,
+                                  PrimitiveMode modePacked,
+                                  const GLint *first,
+                                  const GLsizei *count,
+                                  GLsizei drawcount,
+                                  angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElements_count(const State &glState,
+                                    bool isCallValid,
+                                    PrimitiveMode modePacked,
+                                    const GLsizei *count,
+                                    DrawElementsType typePacked,
+                                    const void *const *indices,
+                                    GLsizei drawcount,
+                                    angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElements_indices(const State &glState,
+                                      bool isCallValid,
+                                      PrimitiveMode modePacked,
+                                      const GLsizei *count,
+                                      DrawElementsType typePacked,
+                                      const void *const *indices,
+                                      GLsizei drawcount,
+                                      angle::ParamCapture *paramCapture);
+void CapturePointParameteriv_params(const State &glState,
+                                    bool isCallValid,
+                                    GLenum pname,
+                                    const GLint *params,
+                                    angle::ParamCapture *paramCapture);
+void CaptureSecondaryColor3bv_v(const State &glState,
+                                bool isCallValid,
+                                const GLbyte *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureSecondaryColor3dv_v(const State &glState,
+                                bool isCallValid,
+                                const GLdouble *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureSecondaryColor3fv_v(const State &glState,
+                                bool isCallValid,
+                                const GLfloat *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureSecondaryColor3iv_v(const State &glState,
+                                bool isCallValid,
+                                const GLint *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureSecondaryColor3sv_v(const State &glState,
+                                bool isCallValid,
+                                const GLshort *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureSecondaryColor3ubv_v(const State &glState,
+                                 bool isCallValid,
+                                 const GLubyte *v,
+                                 angle::ParamCapture *paramCapture);
+void CaptureSecondaryColor3uiv_v(const State &glState,
+                                 bool isCallValid,
+                                 const GLuint *v,
+                                 angle::ParamCapture *paramCapture);
+void CaptureSecondaryColor3usv_v(const State &glState,
+                                 bool isCallValid,
+                                 const GLushort *v,
+                                 angle::ParamCapture *paramCapture);
+void CaptureSecondaryColorPointer_pointer(const State &glState,
+                                          bool isCallValid,
+                                          GLint size,
+                                          GLenum type,
+                                          GLsizei stride,
+                                          const void *pointer,
+                                          angle::ParamCapture *paramCapture);
+void CaptureWindowPos2dv_v(const State &glState,
+                           bool isCallValid,
+                           const GLdouble *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureWindowPos2fv_v(const State &glState,
+                           bool isCallValid,
+                           const GLfloat *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureWindowPos2iv_v(const State &glState,
+                           bool isCallValid,
+                           const GLint *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureWindowPos2sv_v(const State &glState,
+                           bool isCallValid,
+                           const GLshort *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureWindowPos3dv_v(const State &glState,
+                           bool isCallValid,
+                           const GLdouble *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureWindowPos3fv_v(const State &glState,
+                           bool isCallValid,
+                           const GLfloat *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureWindowPos3iv_v(const State &glState,
+                           bool isCallValid,
+                           const GLint *v,
+                           angle::ParamCapture *paramCapture);
+void CaptureWindowPos3sv_v(const State &glState,
+                           bool isCallValid,
+                           const GLshort *v,
+                           angle::ParamCapture *paramCapture);
+
+// GL 1.5
+void CaptureGetBufferSubData_data(const State &glState,
+                                  bool isCallValid,
+                                  GLenum target,
+                                  GLintptr offset,
+                                  GLsizeiptr size,
+                                  void *data,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectiv_params(const State &glState,
+                                    bool isCallValid,
+                                    QueryID idPacked,
+                                    GLenum pname,
+                                    GLint *params,
+                                    angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gl_2_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_2_autogen.h
new file mode 100644
index 0000000000..5ab30a6b9a
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_2_autogen.h
@@ -0,0 +1,266 @@
+// 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_gl_2_autogen.h:
+//   Capture functions for the OpenGL ES Desktop GL 2.x entry points.
+
+#ifndef LIBANGLE_CAPTURE_GL_2_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GL_2_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+// GL 2.0
+angle::CallCapture CaptureGetVertexAttribdv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLenum pname,
+                                            GLdouble *params);
+angle::CallCapture CaptureVertexAttrib1d(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLdouble x);
+angle::CallCapture CaptureVertexAttrib1dv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLdouble *v);
+angle::CallCapture CaptureVertexAttrib1s(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLshort x);
+angle::CallCapture CaptureVertexAttrib1sv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLshort *v);
+angle::CallCapture CaptureVertexAttrib2d(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLdouble x,
+                                         GLdouble y);
+angle::CallCapture CaptureVertexAttrib2dv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLdouble *v);
+angle::CallCapture CaptureVertexAttrib2s(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLshort x,
+                                         GLshort y);
+angle::CallCapture CaptureVertexAttrib2sv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLshort *v);
+angle::CallCapture CaptureVertexAttrib3d(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLdouble x,
+                                         GLdouble y,
+                                         GLdouble z);
+angle::CallCapture CaptureVertexAttrib3dv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLdouble *v);
+angle::CallCapture CaptureVertexAttrib3s(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLshort x,
+                                         GLshort y,
+                                         GLshort z);
+angle::CallCapture CaptureVertexAttrib3sv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLshort *v);
+angle::CallCapture CaptureVertexAttrib4Nbv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLbyte *v);
+angle::CallCapture CaptureVertexAttrib4Niv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLint *v);
+angle::CallCapture CaptureVertexAttrib4Nsv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLshort *v);
+angle::CallCapture CaptureVertexAttrib4Nub(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLubyte x,
+                                           GLubyte y,
+                                           GLubyte z,
+                                           GLubyte w);
+angle::CallCapture CaptureVertexAttrib4Nubv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLubyte *v);
+angle::CallCapture CaptureVertexAttrib4Nuiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLuint *v);
+angle::CallCapture CaptureVertexAttrib4Nusv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLushort *v);
+angle::CallCapture CaptureVertexAttrib4bv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLbyte *v);
+angle::CallCapture CaptureVertexAttrib4d(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLdouble x,
+                                         GLdouble y,
+                                         GLdouble z,
+                                         GLdouble w);
+angle::CallCapture CaptureVertexAttrib4dv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLdouble *v);
+angle::CallCapture CaptureVertexAttrib4iv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLint *v);
+angle::CallCapture CaptureVertexAttrib4s(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLshort x,
+                                         GLshort y,
+                                         GLshort z,
+                                         GLshort w);
+angle::CallCapture CaptureVertexAttrib4sv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLshort *v);
+angle::CallCapture CaptureVertexAttrib4ubv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLubyte *v);
+angle::CallCapture CaptureVertexAttrib4uiv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLuint *v);
+angle::CallCapture CaptureVertexAttrib4usv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLushort *v);
+
+// GL 2.1
+
+// Parameter Captures
+
+// GL 2.0
+void CaptureGetVertexAttribdv_params(const State &glState,
+                                     bool isCallValid,
+                                     GLuint index,
+                                     GLenum pname,
+                                     GLdouble *params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib1dv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLdouble *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib1sv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLshort *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib2dv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLdouble *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib2sv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLshort *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib3dv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLdouble *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib3sv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLshort *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4Nbv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLbyte *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4Niv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4Nsv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLshort *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4Nubv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLubyte *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4Nuiv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLuint *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4Nusv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLushort *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4bv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLbyte *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4dv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLdouble *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4iv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLint *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4sv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLshort *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4ubv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLubyte *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4uiv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLuint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttrib4usv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLushort *v,
+                               angle::ParamCapture *paramCapture);
+
+// GL 2.1
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GL_2_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gl_3_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_3_autogen.h
new file mode 100644
index 0000000000..b365fbec7c
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_3_autogen.h
@@ -0,0 +1,609 @@
+// 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_gl_3_autogen.h:
+//   Capture functions for the OpenGL ES Desktop GL 3.x entry points.
+
+#ifndef LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+// GL 3.0
+angle::CallCapture CaptureBeginConditionalRender(const State &glState,
+                                                 bool isCallValid,
+                                                 GLuint id,
+                                                 GLenum mode);
+angle::CallCapture CaptureBindFragDataLocation(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               GLuint color,
+                                               const GLchar *name);
+angle::CallCapture CaptureClampColor(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLenum clamp);
+angle::CallCapture CaptureEndConditionalRender(const State &glState, bool isCallValid);
+angle::CallCapture CaptureFramebufferTexture1D(const State &glState,
+                                               bool isCallValid,
+                                               GLenum target,
+                                               GLenum attachment,
+                                               TextureTarget textargetPacked,
+                                               TextureID texturePacked,
+                                               GLint level);
+angle::CallCapture CaptureFramebufferTexture3D(const State &glState,
+                                               bool isCallValid,
+                                               GLenum target,
+                                               GLenum attachment,
+                                               TextureTarget textargetPacked,
+                                               TextureID texturePacked,
+                                               GLint level,
+                                               GLint zoffset);
+angle::CallCapture CaptureVertexAttribI1i(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          GLint x);
+angle::CallCapture CaptureVertexAttribI1iv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLint *v);
+angle::CallCapture CaptureVertexAttribI1ui(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLuint x);
+angle::CallCapture CaptureVertexAttribI1uiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLuint *v);
+angle::CallCapture CaptureVertexAttribI2i(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          GLint x,
+                                          GLint y);
+angle::CallCapture CaptureVertexAttribI2iv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLint *v);
+angle::CallCapture CaptureVertexAttribI2ui(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLuint x,
+                                           GLuint y);
+angle::CallCapture CaptureVertexAttribI2uiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLuint *v);
+angle::CallCapture CaptureVertexAttribI3i(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          GLint x,
+                                          GLint y,
+                                          GLint z);
+angle::CallCapture CaptureVertexAttribI3iv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLint *v);
+angle::CallCapture CaptureVertexAttribI3ui(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLuint x,
+                                           GLuint y,
+                                           GLuint z);
+angle::CallCapture CaptureVertexAttribI3uiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLuint *v);
+angle::CallCapture CaptureVertexAttribI4bv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLbyte *v);
+angle::CallCapture CaptureVertexAttribI4sv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLshort *v);
+angle::CallCapture CaptureVertexAttribI4ubv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLubyte *v);
+angle::CallCapture CaptureVertexAttribI4usv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLushort *v);
+
+// GL 3.1
+angle::CallCapture CaptureGetActiveUniformName(const State &glState,
+                                               bool isCallValid,
+                                               ShaderProgramID programPacked,
+                                               GLuint uniformIndex,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLchar *uniformName);
+angle::CallCapture CapturePrimitiveRestartIndex(const State &glState,
+                                                bool isCallValid,
+                                                GLuint index);
+
+// GL 3.2
+angle::CallCapture CaptureMultiDrawElementsBaseVertex(const State &glState,
+                                                      bool isCallValid,
+                                                      PrimitiveMode modePacked,
+                                                      const GLsizei *count,
+                                                      DrawElementsType typePacked,
+                                                      const void *const *indices,
+                                                      GLsizei drawcount,
+                                                      const GLint *basevertex);
+angle::CallCapture CaptureProvokingVertex(const State &glState,
+                                          bool isCallValid,
+                                          ProvokingVertexConvention modePacked);
+angle::CallCapture CaptureTexImage2DMultisample(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLsizei samples,
+                                                GLenum internalformat,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLboolean fixedsamplelocations);
+angle::CallCapture CaptureTexImage3DMultisample(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLsizei samples,
+                                                GLenum internalformat,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLsizei depth,
+                                                GLboolean fixedsamplelocations);
+
+// GL 3.3
+angle::CallCapture CaptureBindFragDataLocationIndexed(const State &glState,
+                                                      bool isCallValid,
+                                                      ShaderProgramID programPacked,
+                                                      GLuint colorNumber,
+                                                      GLuint index,
+                                                      const GLchar *name);
+angle::CallCapture CaptureColorP3ui(const State &glState,
+                                    bool isCallValid,
+                                    GLenum type,
+                                    GLuint color);
+angle::CallCapture CaptureColorP3uiv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum type,
+                                     const GLuint *color);
+angle::CallCapture CaptureColorP4ui(const State &glState,
+                                    bool isCallValid,
+                                    GLenum type,
+                                    GLuint color);
+angle::CallCapture CaptureColorP4uiv(const State &glState,
+                                     bool isCallValid,
+                                     GLenum type,
+                                     const GLuint *color);
+angle::CallCapture CaptureGetFragDataIndex(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           const GLchar *name,
+                                           GLint returnValue);
+angle::CallCapture CaptureGetQueryObjecti64v(const State &glState,
+                                             bool isCallValid,
+                                             QueryID idPacked,
+                                             GLenum pname,
+                                             GLint64 *params);
+angle::CallCapture CaptureGetQueryObjectui64v(const State &glState,
+                                              bool isCallValid,
+                                              QueryID idPacked,
+                                              GLenum pname,
+                                              GLuint64 *params);
+angle::CallCapture CaptureMultiTexCoordP1ui(const State &glState,
+                                            bool isCallValid,
+                                            GLenum texture,
+                                            GLenum type,
+                                            GLuint coords);
+angle::CallCapture CaptureMultiTexCoordP1uiv(const State &glState,
+                                             bool isCallValid,
+                                             GLenum texture,
+                                             GLenum type,
+                                             const GLuint *coords);
+angle::CallCapture CaptureMultiTexCoordP2ui(const State &glState,
+                                            bool isCallValid,
+                                            GLenum texture,
+                                            GLenum type,
+                                            GLuint coords);
+angle::CallCapture CaptureMultiTexCoordP2uiv(const State &glState,
+                                             bool isCallValid,
+                                             GLenum texture,
+                                             GLenum type,
+                                             const GLuint *coords);
+angle::CallCapture CaptureMultiTexCoordP3ui(const State &glState,
+                                            bool isCallValid,
+                                            GLenum texture,
+                                            GLenum type,
+                                            GLuint coords);
+angle::CallCapture CaptureMultiTexCoordP3uiv(const State &glState,
+                                             bool isCallValid,
+                                             GLenum texture,
+                                             GLenum type,
+                                             const GLuint *coords);
+angle::CallCapture CaptureMultiTexCoordP4ui(const State &glState,
+                                            bool isCallValid,
+                                            GLenum texture,
+                                            GLenum type,
+                                            GLuint coords);
+angle::CallCapture CaptureMultiTexCoordP4uiv(const State &glState,
+                                             bool isCallValid,
+                                             GLenum texture,
+                                             GLenum type,
+                                             const GLuint *coords);
+angle::CallCapture CaptureNormalP3ui(const State &glState,
+                                     bool isCallValid,
+                                     GLenum type,
+                                     GLuint coords);
+angle::CallCapture CaptureNormalP3uiv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum type,
+                                      const GLuint *coords);
+angle::CallCapture CaptureQueryCounter(const State &glState,
+                                       bool isCallValid,
+                                       QueryID idPacked,
+                                       QueryType targetPacked);
+angle::CallCapture CaptureSecondaryColorP3ui(const State &glState,
+                                             bool isCallValid,
+                                             GLenum type,
+                                             GLuint color);
+angle::CallCapture CaptureSecondaryColorP3uiv(const State &glState,
+                                              bool isCallValid,
+                                              GLenum type,
+                                              const GLuint *color);
+angle::CallCapture CaptureTexCoordP1ui(const State &glState,
+                                       bool isCallValid,
+                                       GLenum type,
+                                       GLuint coords);
+angle::CallCapture CaptureTexCoordP1uiv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum type,
+                                        const GLuint *coords);
+angle::CallCapture CaptureTexCoordP2ui(const State &glState,
+                                       bool isCallValid,
+                                       GLenum type,
+                                       GLuint coords);
+angle::CallCapture CaptureTexCoordP2uiv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum type,
+                                        const GLuint *coords);
+angle::CallCapture CaptureTexCoordP3ui(const State &glState,
+                                       bool isCallValid,
+                                       GLenum type,
+                                       GLuint coords);
+angle::CallCapture CaptureTexCoordP3uiv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum type,
+                                        const GLuint *coords);
+angle::CallCapture CaptureTexCoordP4ui(const State &glState,
+                                       bool isCallValid,
+                                       GLenum type,
+                                       GLuint coords);
+angle::CallCapture CaptureTexCoordP4uiv(const State &glState,
+                                        bool isCallValid,
+                                        GLenum type,
+                                        const GLuint *coords);
+angle::CallCapture CaptureVertexAttribP1ui(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLenum type,
+                                           GLboolean normalized,
+                                           GLuint value);
+angle::CallCapture CaptureVertexAttribP1uiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLenum type,
+                                            GLboolean normalized,
+                                            const GLuint *value);
+angle::CallCapture CaptureVertexAttribP2ui(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLenum type,
+                                           GLboolean normalized,
+                                           GLuint value);
+angle::CallCapture CaptureVertexAttribP2uiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLenum type,
+                                            GLboolean normalized,
+                                            const GLuint *value);
+angle::CallCapture CaptureVertexAttribP3ui(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLenum type,
+                                           GLboolean normalized,
+                                           GLuint value);
+angle::CallCapture CaptureVertexAttribP3uiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLenum type,
+                                            GLboolean normalized,
+                                            const GLuint *value);
+angle::CallCapture CaptureVertexAttribP4ui(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLenum type,
+                                           GLboolean normalized,
+                                           GLuint value);
+angle::CallCapture CaptureVertexAttribP4uiv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLenum type,
+                                            GLboolean normalized,
+                                            const GLuint *value);
+angle::CallCapture CaptureVertexP2ui(const State &glState,
+                                     bool isCallValid,
+                                     GLenum type,
+                                     GLuint value);
+angle::CallCapture CaptureVertexP2uiv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum type,
+                                      const GLuint *value);
+angle::CallCapture CaptureVertexP3ui(const State &glState,
+                                     bool isCallValid,
+                                     GLenum type,
+                                     GLuint value);
+angle::CallCapture CaptureVertexP3uiv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum type,
+                                      const GLuint *value);
+angle::CallCapture CaptureVertexP4ui(const State &glState,
+                                     bool isCallValid,
+                                     GLenum type,
+                                     GLuint value);
+angle::CallCapture CaptureVertexP4uiv(const State &glState,
+                                      bool isCallValid,
+                                      GLenum type,
+                                      const GLuint *value);
+
+// Parameter Captures
+
+// GL 3.0
+void CaptureBindFragDataLocation_name(const State &glState,
+                                      bool isCallValid,
+                                      ShaderProgramID programPacked,
+                                      GLuint color,
+                                      const GLchar *name,
+                                      angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI1iv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI1uiv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLuint *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI2iv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI2uiv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLuint *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI3iv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLint *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI3uiv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLuint *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI4bv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLbyte *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI4sv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLshort *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI4ubv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLubyte *v,
+                                angle::ParamCapture *paramCapture);
+void CaptureVertexAttribI4usv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLushort *v,
+                                angle::ParamCapture *paramCapture);
+
+// GL 3.1
+void CaptureGetActiveUniformName_length(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        GLuint uniformIndex,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLchar *uniformName,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetActiveUniformName_uniformName(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLuint uniformIndex,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLchar *uniformName,
+                                             angle::ParamCapture *paramCapture);
+
+// GL 3.2
+void CaptureMultiDrawElementsBaseVertex_count(const State &glState,
+                                              bool isCallValid,
+                                              PrimitiveMode modePacked,
+                                              const GLsizei *count,
+                                              DrawElementsType typePacked,
+                                              const void *const *indices,
+                                              GLsizei drawcount,
+                                              const GLint *basevertex,
+                                              angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsBaseVertex_indices(const State &glState,
+                                                bool isCallValid,
+                                                PrimitiveMode modePacked,
+                                                const GLsizei *count,
+                                                DrawElementsType typePacked,
+                                                const void *const *indices,
+                                                GLsizei drawcount,
+                                                const GLint *basevertex,
+                                                angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsBaseVertex_basevertex(const State &glState,
+                                                   bool isCallValid,
+                                                   PrimitiveMode modePacked,
+                                                   const GLsizei *count,
+                                                   DrawElementsType typePacked,
+                                                   const void *const *indices,
+                                                   GLsizei drawcount,
+                                                   const GLint *basevertex,
+                                                   angle::ParamCapture *paramCapture);
+
+// GL 3.3
+void CaptureBindFragDataLocationIndexed_name(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLuint colorNumber,
+                                             GLuint index,
+                                             const GLchar *name,
+                                             angle::ParamCapture *paramCapture);
+void CaptureColorP3uiv_color(const State &glState,
+                             bool isCallValid,
+                             GLenum type,
+                             const GLuint *color,
+                             angle::ParamCapture *paramCapture);
+void CaptureColorP4uiv_color(const State &glState,
+                             bool isCallValid,
+                             GLenum type,
+                             const GLuint *color,
+                             angle::ParamCapture *paramCapture);
+void CaptureGetFragDataIndex_name(const State &glState,
+                                  bool isCallValid,
+                                  ShaderProgramID programPacked,
+                                  const GLchar *name,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjecti64v_params(const State &glState,
+                                      bool isCallValid,
+                                      QueryID idPacked,
+                                      GLenum pname,
+                                      GLint64 *params,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGetQueryObjectui64v_params(const State &glState,
+                                       bool isCallValid,
+                                       QueryID idPacked,
+                                       GLenum pname,
+                                       GLuint64 *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoordP1uiv_coords(const State &glState,
+                                      bool isCallValid,
+                                      GLenum texture,
+                                      GLenum type,
+                                      const GLuint *coords,
+                                      angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoordP2uiv_coords(const State &glState,
+                                      bool isCallValid,
+                                      GLenum texture,
+                                      GLenum type,
+                                      const GLuint *coords,
+                                      angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoordP3uiv_coords(const State &glState,
+                                      bool isCallValid,
+                                      GLenum texture,
+                                      GLenum type,
+                                      const GLuint *coords,
+                                      angle::ParamCapture *paramCapture);
+void CaptureMultiTexCoordP4uiv_coords(const State &glState,
+                                      bool isCallValid,
+                                      GLenum texture,
+                                      GLenum type,
+                                      const GLuint *coords,
+                                      angle::ParamCapture *paramCapture);
+void CaptureNormalP3uiv_coords(const State &glState,
+                               bool isCallValid,
+                               GLenum type,
+                               const GLuint *coords,
+                               angle::ParamCapture *paramCapture);
+void CaptureSecondaryColorP3uiv_color(const State &glState,
+                                      bool isCallValid,
+                                      GLenum type,
+                                      const GLuint *color,
+                                      angle::ParamCapture *paramCapture);
+void CaptureTexCoordP1uiv_coords(const State &glState,
+                                 bool isCallValid,
+                                 GLenum type,
+                                 const GLuint *coords,
+                                 angle::ParamCapture *paramCapture);
+void CaptureTexCoordP2uiv_coords(const State &glState,
+                                 bool isCallValid,
+                                 GLenum type,
+                                 const GLuint *coords,
+                                 angle::ParamCapture *paramCapture);
+void CaptureTexCoordP3uiv_coords(const State &glState,
+                                 bool isCallValid,
+                                 GLenum type,
+                                 const GLuint *coords,
+                                 angle::ParamCapture *paramCapture);
+void CaptureTexCoordP4uiv_coords(const State &glState,
+                                 bool isCallValid,
+                                 GLenum type,
+                                 const GLuint *coords,
+                                 angle::ParamCapture *paramCapture);
+void CaptureVertexAttribP1uiv_value(const State &glState,
+                                    bool isCallValid,
+                                    GLuint index,
+                                    GLenum type,
+                                    GLboolean normalized,
+                                    const GLuint *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureVertexAttribP2uiv_value(const State &glState,
+                                    bool isCallValid,
+                                    GLuint index,
+                                    GLenum type,
+                                    GLboolean normalized,
+                                    const GLuint *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureVertexAttribP3uiv_value(const State &glState,
+                                    bool isCallValid,
+                                    GLuint index,
+                                    GLenum type,
+                                    GLboolean normalized,
+                                    const GLuint *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureVertexAttribP4uiv_value(const State &glState,
+                                    bool isCallValid,
+                                    GLuint index,
+                                    GLenum type,
+                                    GLboolean normalized,
+                                    const GLuint *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureVertexP2uiv_value(const State &glState,
+                              bool isCallValid,
+                              GLenum type,
+                              const GLuint *value,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexP3uiv_value(const State &glState,
+                              bool isCallValid,
+                              GLenum type,
+                              const GLuint *value,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexP4uiv_value(const State &glState,
+                              bool isCallValid,
+                              GLenum type,
+                              const GLuint *value,
+                              angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gl_4_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_4_autogen.h
new file mode 100644
index 0000000000..495bf4cb7f
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_4_autogen.h
@@ -0,0 +1,2524 @@
+// 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_gl_4_autogen.h:
+//   Capture functions for the OpenGL ES Desktop GL 4.x entry points.
+
+#ifndef LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
+#define LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
+
+#include "common/PackedEnums.h"
+#include "libANGLE/capture/FrameCapture.h"
+
+namespace gl
+{
+
+// Method Captures
+
+// GL 4.0
+angle::CallCapture CaptureBeginQueryIndexed(const State &glState,
+                                            bool isCallValid,
+                                            GLenum target,
+                                            GLuint index,
+                                            QueryID idPacked);
+angle::CallCapture CaptureDrawTransformFeedback(const State &glState,
+                                                bool isCallValid,
+                                                GLenum mode,
+                                                TransformFeedbackID idPacked);
+angle::CallCapture CaptureDrawTransformFeedbackStream(const State &glState,
+                                                      bool isCallValid,
+                                                      GLenum mode,
+                                                      TransformFeedbackID idPacked,
+                                                      GLuint stream);
+angle::CallCapture CaptureEndQueryIndexed(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLuint index);
+angle::CallCapture CaptureGetActiveSubroutineName(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  GLenum shadertype,
+                                                  GLuint index,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLchar *name);
+angle::CallCapture CaptureGetActiveSubroutineUniformName(const State &glState,
+                                                         bool isCallValid,
+                                                         ShaderProgramID programPacked,
+                                                         GLenum shadertype,
+                                                         GLuint index,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLchar *name);
+angle::CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState,
+                                                       bool isCallValid,
+                                                       ShaderProgramID programPacked,
+                                                       GLenum shadertype,
+                                                       GLuint index,
+                                                       GLenum pname,
+                                                       GLint *values);
+angle::CallCapture CaptureGetProgramStageiv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            GLenum shadertype,
+                                            GLenum pname,
+                                            GLint *values);
+angle::CallCapture CaptureGetQueryIndexediv(const State &glState,
+                                            bool isCallValid,
+                                            GLenum target,
+                                            GLuint index,
+                                            GLenum pname,
+                                            GLint *params);
+angle::CallCapture CaptureGetSubroutineIndex(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             GLenum shadertype,
+                                             const GLchar *name,
+                                             GLuint returnValue);
+angle::CallCapture CaptureGetSubroutineUniformLocation(const State &glState,
+                                                       bool isCallValid,
+                                                       ShaderProgramID programPacked,
+                                                       GLenum shadertype,
+                                                       const GLchar *name,
+                                                       GLint returnValue);
+angle::CallCapture CaptureGetUniformSubroutineuiv(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum shadertype,
+                                                  GLint location,
+                                                  GLuint *params);
+angle::CallCapture CaptureGetUniformdv(const State &glState,
+                                       bool isCallValid,
+                                       ShaderProgramID programPacked,
+                                       UniformLocation locationPacked,
+                                       GLdouble *params);
+angle::CallCapture CapturePatchParameterfv(const State &glState,
+                                           bool isCallValid,
+                                           GLenum pname,
+                                           const GLfloat *values);
+angle::CallCapture CaptureUniform1d(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLdouble x);
+angle::CallCapture CaptureUniform1dv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLdouble *value);
+angle::CallCapture CaptureUniform2d(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLdouble x,
+                                    GLdouble y);
+angle::CallCapture CaptureUniform2dv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLdouble *value);
+angle::CallCapture CaptureUniform3d(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLdouble x,
+                                    GLdouble y,
+                                    GLdouble z);
+angle::CallCapture CaptureUniform3dv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLdouble *value);
+angle::CallCapture CaptureUniform4d(const State &glState,
+                                    bool isCallValid,
+                                    UniformLocation locationPacked,
+                                    GLdouble x,
+                                    GLdouble y,
+                                    GLdouble z,
+                                    GLdouble w);
+angle::CallCapture CaptureUniform4dv(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix2dv(const State &glState,
+                                           bool isCallValid,
+                                           UniformLocation locationPacked,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix2x3dv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix2x4dv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix3dv(const State &glState,
+                                           bool isCallValid,
+                                           UniformLocation locationPacked,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix3x2dv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix3x4dv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix4dv(const State &glState,
+                                           bool isCallValid,
+                                           UniformLocation locationPacked,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix4x2dv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLdouble *value);
+angle::CallCapture CaptureUniformMatrix4x3dv(const State &glState,
+                                             bool isCallValid,
+                                             UniformLocation locationPacked,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLdouble *value);
+angle::CallCapture CaptureUniformSubroutinesuiv(const State &glState,
+                                                bool isCallValid,
+                                                GLenum shadertype,
+                                                GLsizei count,
+                                                const GLuint *indices);
+
+// GL 4.1
+angle::CallCapture CaptureDepthRangeArrayv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint first,
+                                           GLsizei count,
+                                           const GLdouble *v);
+angle::CallCapture CaptureDepthRangeIndexed(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            GLdouble n,
+                                            GLdouble f);
+angle::CallCapture CaptureGetDoublei_v(const State &glState,
+                                       bool isCallValid,
+                                       GLenum target,
+                                       GLuint index,
+                                       GLdouble *data);
+angle::CallCapture CaptureGetFloati_v(const State &glState,
+                                      bool isCallValid,
+                                      GLenum target,
+                                      GLuint index,
+                                      GLfloat *data);
+angle::CallCapture CaptureGetVertexAttribLdv(const State &glState,
+                                             bool isCallValid,
+                                             GLuint index,
+                                             GLenum pname,
+                                             GLdouble *params);
+angle::CallCapture CaptureProgramUniform1d(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLdouble v0);
+angle::CallCapture CaptureProgramUniform1dv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLdouble *value);
+angle::CallCapture CaptureProgramUniform2d(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLdouble v0,
+                                           GLdouble v1);
+angle::CallCapture CaptureProgramUniform2dv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLdouble *value);
+angle::CallCapture CaptureProgramUniform3d(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLdouble v0,
+                                           GLdouble v1,
+                                           GLdouble v2);
+angle::CallCapture CaptureProgramUniform3dv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLdouble *value);
+angle::CallCapture CaptureProgramUniform4d(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLdouble v0,
+                                           GLdouble v1,
+                                           GLdouble v2,
+                                           GLdouble v3);
+angle::CallCapture CaptureProgramUniform4dv(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix2dv(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformLocation locationPacked,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix2x3dv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix2x4dv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix3dv(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformLocation locationPacked,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix3x2dv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix3x4dv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix4dv(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  UniformLocation locationPacked,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix4x2dv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLdouble *value);
+angle::CallCapture CaptureProgramUniformMatrix4x3dv(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    UniformLocation locationPacked,
+                                                    GLsizei count,
+                                                    GLboolean transpose,
+                                                    const GLdouble *value);
+angle::CallCapture CaptureScissorArrayv(const State &glState,
+                                        bool isCallValid,
+                                        GLuint first,
+                                        GLsizei count,
+                                        const GLint *v);
+angle::CallCapture CaptureScissorIndexed(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLint left,
+                                         GLint bottom,
+                                         GLsizei width,
+                                         GLsizei height);
+angle::CallCapture CaptureScissorIndexedv(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          const GLint *v);
+angle::CallCapture CaptureVertexAttribL1d(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          GLdouble x);
+angle::CallCapture CaptureVertexAttribL1dv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLdouble *v);
+angle::CallCapture CaptureVertexAttribL2d(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          GLdouble x,
+                                          GLdouble y);
+angle::CallCapture CaptureVertexAttribL2dv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLdouble *v);
+angle::CallCapture CaptureVertexAttribL3d(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          GLdouble x,
+                                          GLdouble y,
+                                          GLdouble z);
+angle::CallCapture CaptureVertexAttribL3dv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLdouble *v);
+angle::CallCapture CaptureVertexAttribL4d(const State &glState,
+                                          bool isCallValid,
+                                          GLuint index,
+                                          GLdouble x,
+                                          GLdouble y,
+                                          GLdouble z,
+                                          GLdouble w);
+angle::CallCapture CaptureVertexAttribL4dv(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           const GLdouble *v);
+angle::CallCapture CaptureVertexAttribLPointer(const State &glState,
+                                               bool isCallValid,
+                                               GLuint index,
+                                               GLint size,
+                                               GLenum type,
+                                               GLsizei stride,
+                                               const void *pointer);
+angle::CallCapture CaptureViewportArrayv(const State &glState,
+                                         bool isCallValid,
+                                         GLuint first,
+                                         GLsizei count,
+                                         const GLfloat *v);
+angle::CallCapture CaptureViewportIndexedf(const State &glState,
+                                           bool isCallValid,
+                                           GLuint index,
+                                           GLfloat x,
+                                           GLfloat y,
+                                           GLfloat w,
+                                           GLfloat h);
+angle::CallCapture CaptureViewportIndexedfv(const State &glState,
+                                            bool isCallValid,
+                                            GLuint index,
+                                            const GLfloat *v);
+
+// GL 4.2
+angle::CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState,
+                                                          bool isCallValid,
+                                                          PrimitiveMode modePacked,
+                                                          GLint first,
+                                                          GLsizei count,
+                                                          GLsizei instancecount,
+                                                          GLuint baseinstance);
+angle::CallCapture CaptureDrawElementsInstancedBaseInstance(const State &glState,
+                                                            bool isCallValid,
+                                                            PrimitiveMode modePacked,
+                                                            GLsizei count,
+                                                            DrawElementsType typePacked,
+                                                            const void *indices,
+                                                            GLsizei instancecount,
+                                                            GLuint baseinstance);
+angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstance(const State &glState,
+                                                                      bool isCallValid,
+                                                                      PrimitiveMode modePacked,
+                                                                      GLsizei count,
+                                                                      DrawElementsType typePacked,
+                                                                      const void *indices,
+                                                                      GLsizei instancecount,
+                                                                      GLint basevertex,
+                                                                      GLuint baseinstance);
+angle::CallCapture CaptureDrawTransformFeedbackInstanced(const State &glState,
+                                                         bool isCallValid,
+                                                         GLenum mode,
+                                                         TransformFeedbackID idPacked,
+                                                         GLsizei instancecount);
+angle::CallCapture CaptureDrawTransformFeedbackStreamInstanced(const State &glState,
+                                                               bool isCallValid,
+                                                               GLenum mode,
+                                                               TransformFeedbackID idPacked,
+                                                               GLuint stream,
+                                                               GLsizei instancecount);
+angle::CallCapture CaptureGetActiveAtomicCounterBufferiv(const State &glState,
+                                                         bool isCallValid,
+                                                         ShaderProgramID programPacked,
+                                                         GLuint bufferIndex,
+                                                         GLenum pname,
+                                                         GLint *params);
+angle::CallCapture CaptureTexStorage1D(const State &glState,
+                                       bool isCallValid,
+                                       GLenum target,
+                                       GLsizei levels,
+                                       GLenum internalformat,
+                                       GLsizei width);
+
+// GL 4.3
+angle::CallCapture CaptureClearBufferData(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLenum internalformat,
+                                          GLenum format,
+                                          GLenum type,
+                                          const void *data);
+angle::CallCapture CaptureClearBufferSubData(const State &glState,
+                                             bool isCallValid,
+                                             GLenum target,
+                                             GLenum internalformat,
+                                             GLintptr offset,
+                                             GLsizeiptr size,
+                                             GLenum format,
+                                             GLenum type,
+                                             const void *data);
+angle::CallCapture CaptureGetInternalformati64v(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLenum internalformat,
+                                                GLenum pname,
+                                                GLsizei count,
+                                                GLint64 *params);
+angle::CallCapture CaptureGetProgramResourceLocationIndex(const State &glState,
+                                                          bool isCallValid,
+                                                          ShaderProgramID programPacked,
+                                                          GLenum programInterface,
+                                                          const GLchar *name,
+                                                          GLint returnValue);
+angle::CallCapture CaptureInvalidateBufferData(const State &glState,
+                                               bool isCallValid,
+                                               BufferID bufferPacked);
+angle::CallCapture CaptureInvalidateBufferSubData(const State &glState,
+                                                  bool isCallValid,
+                                                  BufferID bufferPacked,
+                                                  GLintptr offset,
+                                                  GLsizeiptr length);
+angle::CallCapture CaptureInvalidateTexImage(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             GLint level);
+angle::CallCapture CaptureInvalidateTexSubImage(const State &glState,
+                                                bool isCallValid,
+                                                TextureID texturePacked,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint zoffset,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLsizei depth);
+angle::CallCapture CaptureMultiDrawArraysIndirect(const State &glState,
+                                                  bool isCallValid,
+                                                  PrimitiveMode modePacked,
+                                                  const void *indirect,
+                                                  GLsizei drawcount,
+                                                  GLsizei stride);
+angle::CallCapture CaptureMultiDrawElementsIndirect(const State &glState,
+                                                    bool isCallValid,
+                                                    PrimitiveMode modePacked,
+                                                    DrawElementsType typePacked,
+                                                    const void *indirect,
+                                                    GLsizei drawcount,
+                                                    GLsizei stride);
+angle::CallCapture CaptureShaderStorageBlockBinding(const State &glState,
+                                                    bool isCallValid,
+                                                    ShaderProgramID programPacked,
+                                                    GLuint storageBlockIndex,
+                                                    GLuint storageBlockBinding);
+angle::CallCapture CaptureTextureView(const State &glState,
+                                      bool isCallValid,
+                                      TextureID texturePacked,
+                                      GLenum target,
+                                      GLuint origtexture,
+                                      GLenum internalformat,
+                                      GLuint minlevel,
+                                      GLuint numlevels,
+                                      GLuint minlayer,
+                                      GLuint numlayers);
+angle::CallCapture CaptureVertexAttribLFormat(const State &glState,
+                                              bool isCallValid,
+                                              GLuint attribindex,
+                                              GLint size,
+                                              GLenum type,
+                                              GLuint relativeoffset);
+
+// GL 4.4
+angle::CallCapture CaptureBindBuffersBase(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLuint first,
+                                          GLsizei count,
+                                          const BufferID *buffersPacked);
+angle::CallCapture CaptureBindBuffersRange(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           GLuint first,
+                                           GLsizei count,
+                                           const BufferID *buffersPacked,
+                                           const GLintptr *offsets,
+                                           const GLsizeiptr *sizes);
+angle::CallCapture CaptureBindImageTextures(const State &glState,
+                                            bool isCallValid,
+                                            GLuint first,
+                                            GLsizei count,
+                                            const GLuint *textures);
+angle::CallCapture CaptureBindSamplers(const State &glState,
+                                       bool isCallValid,
+                                       GLuint first,
+                                       GLsizei count,
+                                       const GLuint *samplers);
+angle::CallCapture CaptureBindTextures(const State &glState,
+                                       bool isCallValid,
+                                       GLuint first,
+                                       GLsizei count,
+                                       const GLuint *textures);
+angle::CallCapture CaptureBindVertexBuffers(const State &glState,
+                                            bool isCallValid,
+                                            GLuint first,
+                                            GLsizei count,
+                                            const BufferID *buffersPacked,
+                                            const GLintptr *offsets,
+                                            const GLsizei *strides);
+angle::CallCapture CaptureBufferStorage(const State &glState,
+                                        bool isCallValid,
+                                        BufferBinding targetPacked,
+                                        GLsizeiptr size,
+                                        const void *data,
+                                        GLbitfield flags);
+angle::CallCapture CaptureClearTexImage(const State &glState,
+                                        bool isCallValid,
+                                        TextureID texturePacked,
+                                        GLint level,
+                                        GLenum format,
+                                        GLenum type,
+                                        const void *data);
+angle::CallCapture CaptureClearTexSubImage(const State &glState,
+                                           bool isCallValid,
+                                           TextureID texturePacked,
+                                           GLint level,
+                                           GLint xoffset,
+                                           GLint yoffset,
+                                           GLint zoffset,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth,
+                                           GLenum format,
+                                           GLenum type,
+                                           const void *data);
+
+// GL 4.5
+angle::CallCapture CaptureBindTextureUnit(const State &glState,
+                                          bool isCallValid,
+                                          GLuint unit,
+                                          TextureID texturePacked);
+angle::CallCapture CaptureBlitNamedFramebuffer(const State &glState,
+                                               bool isCallValid,
+                                               GLuint readFramebuffer,
+                                               GLuint drawFramebuffer,
+                                               GLint srcX0,
+                                               GLint srcY0,
+                                               GLint srcX1,
+                                               GLint srcY1,
+                                               GLint dstX0,
+                                               GLint dstY0,
+                                               GLint dstX1,
+                                               GLint dstY1,
+                                               GLbitfield mask,
+                                               GLenum filter);
+angle::CallCapture CaptureCheckNamedFramebufferStatus(const State &glState,
+                                                      bool isCallValid,
+                                                      FramebufferID framebufferPacked,
+                                                      GLenum target,
+                                                      GLenum returnValue);
+angle::CallCapture CaptureClearNamedBufferData(const State &glState,
+                                               bool isCallValid,
+                                               BufferID bufferPacked,
+                                               GLenum internalformat,
+                                               GLenum format,
+                                               GLenum type,
+                                               const void *data);
+angle::CallCapture CaptureClearNamedBufferSubData(const State &glState,
+                                                  bool isCallValid,
+                                                  BufferID bufferPacked,
+                                                  GLenum internalformat,
+                                                  GLintptr offset,
+                                                  GLsizeiptr size,
+                                                  GLenum format,
+                                                  GLenum type,
+                                                  const void *data);
+angle::CallCapture CaptureClearNamedFramebufferfi(const State &glState,
+                                                  bool isCallValid,
+                                                  FramebufferID framebufferPacked,
+                                                  GLenum buffer,
+                                                  GLint drawbuffer,
+                                                  GLfloat depth,
+                                                  GLint stencil);
+angle::CallCapture CaptureClearNamedFramebufferfv(const State &glState,
+                                                  bool isCallValid,
+                                                  FramebufferID framebufferPacked,
+                                                  GLenum buffer,
+                                                  GLint drawbuffer,
+                                                  const GLfloat *value);
+angle::CallCapture CaptureClearNamedFramebufferiv(const State &glState,
+                                                  bool isCallValid,
+                                                  FramebufferID framebufferPacked,
+                                                  GLenum buffer,
+                                                  GLint drawbuffer,
+                                                  const GLint *value);
+angle::CallCapture CaptureClearNamedFramebufferuiv(const State &glState,
+                                                   bool isCallValid,
+                                                   FramebufferID framebufferPacked,
+                                                   GLenum buffer,
+                                                   GLint drawbuffer,
+                                                   const GLuint *value);
+angle::CallCapture CaptureClipControl(const State &glState,
+                                      bool isCallValid,
+                                      GLenum origin,
+                                      GLenum depth);
+angle::CallCapture CaptureCompressedTextureSubImage1D(const State &glState,
+                                                      bool isCallValid,
+                                                      TextureID texturePacked,
+                                                      GLint level,
+                                                      GLint xoffset,
+                                                      GLsizei width,
+                                                      GLenum format,
+                                                      GLsizei imageSize,
+                                                      const void *data);
+angle::CallCapture CaptureCompressedTextureSubImage2D(const State &glState,
+                                                      bool isCallValid,
+                                                      TextureID texturePacked,
+                                                      GLint level,
+                                                      GLint xoffset,
+                                                      GLint yoffset,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLenum format,
+                                                      GLsizei imageSize,
+                                                      const void *data);
+angle::CallCapture CaptureCompressedTextureSubImage3D(const State &glState,
+                                                      bool isCallValid,
+                                                      TextureID texturePacked,
+                                                      GLint level,
+                                                      GLint xoffset,
+                                                      GLint yoffset,
+                                                      GLint zoffset,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLsizei depth,
+                                                      GLenum format,
+                                                      GLsizei imageSize,
+                                                      const void *data);
+angle::CallCapture CaptureCopyNamedBufferSubData(const State &glState,
+                                                 bool isCallValid,
+                                                 GLuint readBuffer,
+                                                 GLuint writeBuffer,
+                                                 GLintptr readOffset,
+                                                 GLintptr writeOffset,
+                                                 GLsizeiptr size);
+angle::CallCapture CaptureCopyTextureSubImage1D(const State &glState,
+                                                bool isCallValid,
+                                                TextureID texturePacked,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint x,
+                                                GLint y,
+                                                GLsizei width);
+angle::CallCapture CaptureCopyTextureSubImage2D(const State &glState,
+                                                bool isCallValid,
+                                                TextureID texturePacked,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint x,
+                                                GLint y,
+                                                GLsizei width,
+                                                GLsizei height);
+angle::CallCapture CaptureCopyTextureSubImage3D(const State &glState,
+                                                bool isCallValid,
+                                                TextureID texturePacked,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint zoffset,
+                                                GLint x,
+                                                GLint y,
+                                                GLsizei width,
+                                                GLsizei height);
+angle::CallCapture CaptureCreateBuffers(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        BufferID *buffersPacked);
+angle::CallCapture CaptureCreateFramebuffers(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             GLuint *framebuffers);
+angle::CallCapture CaptureCreateProgramPipelines(const State &glState,
+                                                 bool isCallValid,
+                                                 GLsizei n,
+                                                 GLuint *pipelines);
+angle::CallCapture CaptureCreateQueries(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLsizei n,
+                                        GLuint *ids);
+angle::CallCapture CaptureCreateRenderbuffers(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              RenderbufferID *renderbuffersPacked);
+angle::CallCapture CaptureCreateSamplers(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei n,
+                                         GLuint *samplers);
+angle::CallCapture CaptureCreateTextures(const State &glState,
+                                         bool isCallValid,
+                                         GLenum target,
+                                         GLsizei n,
+                                         GLuint *textures);
+angle::CallCapture CaptureCreateTransformFeedbacks(const State &glState,
+                                                   bool isCallValid,
+                                                   GLsizei n,
+                                                   GLuint *ids);
+angle::CallCapture CaptureCreateVertexArrays(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             VertexArrayID *arraysPacked);
+angle::CallCapture CaptureDisableVertexArrayAttrib(const State &glState,
+                                                   bool isCallValid,
+                                                   VertexArrayID vaobjPacked,
+                                                   GLuint index);
+angle::CallCapture CaptureEnableVertexArrayAttrib(const State &glState,
+                                                  bool isCallValid,
+                                                  VertexArrayID vaobjPacked,
+                                                  GLuint index);
+angle::CallCapture CaptureFlushMappedNamedBufferRange(const State &glState,
+                                                      bool isCallValid,
+                                                      BufferID bufferPacked,
+                                                      GLintptr offset,
+                                                      GLsizeiptr length);
+angle::CallCapture CaptureGenerateTextureMipmap(const State &glState,
+                                                bool isCallValid,
+                                                TextureID texturePacked);
+angle::CallCapture CaptureGetCompressedTextureImage(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureID texturePacked,
+                                                    GLint level,
+                                                    GLsizei bufSize,
+                                                    void *pixels);
+angle::CallCapture CaptureGetCompressedTextureSubImage(const State &glState,
+                                                       bool isCallValid,
+                                                       TextureID texturePacked,
+                                                       GLint level,
+                                                       GLint xoffset,
+                                                       GLint yoffset,
+                                                       GLint zoffset,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLsizei depth,
+                                                       GLsizei bufSize,
+                                                       void *pixels);
+angle::CallCapture CaptureGetNamedBufferParameteri64v(const State &glState,
+                                                      bool isCallValid,
+                                                      BufferID bufferPacked,
+                                                      GLenum pname,
+                                                      GLint64 *params);
+angle::CallCapture CaptureGetNamedBufferParameteriv(const State &glState,
+                                                    bool isCallValid,
+                                                    BufferID bufferPacked,
+                                                    GLenum pname,
+                                                    GLint *params);
+angle::CallCapture CaptureGetNamedBufferPointerv(const State &glState,
+                                                 bool isCallValid,
+                                                 BufferID bufferPacked,
+                                                 GLenum pname,
+                                                 void **params);
+angle::CallCapture CaptureGetNamedBufferSubData(const State &glState,
+                                                bool isCallValid,
+                                                BufferID bufferPacked,
+                                                GLintptr offset,
+                                                GLsizeiptr size,
+                                                void *data);
+angle::CallCapture CaptureGetNamedFramebufferAttachmentParameteriv(const State &glState,
+                                                                   bool isCallValid,
+                                                                   FramebufferID framebufferPacked,
+                                                                   GLenum attachment,
+                                                                   GLenum pname,
+                                                                   GLint *params);
+angle::CallCapture CaptureGetNamedFramebufferParameteriv(const State &glState,
+                                                         bool isCallValid,
+                                                         FramebufferID framebufferPacked,
+                                                         GLenum pname,
+                                                         GLint *param);
+angle::CallCapture CaptureGetNamedRenderbufferParameteriv(const State &glState,
+                                                          bool isCallValid,
+                                                          RenderbufferID renderbufferPacked,
+                                                          GLenum pname,
+                                                          GLint *params);
+angle::CallCapture CaptureGetQueryBufferObjecti64v(const State &glState,
+                                                   bool isCallValid,
+                                                   GLuint id,
+                                                   BufferID bufferPacked,
+                                                   GLenum pname,
+                                                   GLintptr offset);
+angle::CallCapture CaptureGetQueryBufferObjectiv(const State &glState,
+                                                 bool isCallValid,
+                                                 GLuint id,
+                                                 BufferID bufferPacked,
+                                                 GLenum pname,
+                                                 GLintptr offset);
+angle::CallCapture CaptureGetQueryBufferObjectui64v(const State &glState,
+                                                    bool isCallValid,
+                                                    GLuint id,
+                                                    BufferID bufferPacked,
+                                                    GLenum pname,
+                                                    GLintptr offset);
+angle::CallCapture CaptureGetQueryBufferObjectuiv(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint id,
+                                                  BufferID bufferPacked,
+                                                  GLenum pname,
+                                                  GLintptr offset);
+angle::CallCapture CaptureGetTextureImage(const State &glState,
+                                          bool isCallValid,
+                                          TextureID texturePacked,
+                                          GLint level,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          void *pixels);
+angle::CallCapture CaptureGetTextureLevelParameterfv(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureID texturePacked,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLfloat *params);
+angle::CallCapture CaptureGetTextureLevelParameteriv(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureID texturePacked,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLint *params);
+angle::CallCapture CaptureGetTextureParameterIiv(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureID texturePacked,
+                                                 GLenum pname,
+                                                 GLint *params);
+angle::CallCapture CaptureGetTextureParameterIuiv(const State &glState,
+                                                  bool isCallValid,
+                                                  TextureID texturePacked,
+                                                  GLenum pname,
+                                                  GLuint *params);
+angle::CallCapture CaptureGetTextureParameterfv(const State &glState,
+                                                bool isCallValid,
+                                                TextureID texturePacked,
+                                                GLenum pname,
+                                                GLfloat *params);
+angle::CallCapture CaptureGetTextureParameteriv(const State &glState,
+                                                bool isCallValid,
+                                                TextureID texturePacked,
+                                                GLenum pname,
+                                                GLint *params);
+angle::CallCapture CaptureGetTextureSubImage(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLint yoffset,
+                                             GLint zoffset,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLsizei depth,
+                                             GLenum format,
+                                             GLenum type,
+                                             GLsizei bufSize,
+                                             void *pixels);
+angle::CallCapture CaptureGetTransformFeedbacki64_v(const State &glState,
+                                                    bool isCallValid,
+                                                    GLuint xfb,
+                                                    GLenum pname,
+                                                    GLuint index,
+                                                    GLint64 *param);
+angle::CallCapture CaptureGetTransformFeedbacki_v(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint xfb,
+                                                  GLenum pname,
+                                                  GLuint index,
+                                                  GLint *param);
+angle::CallCapture CaptureGetTransformFeedbackiv(const State &glState,
+                                                 bool isCallValid,
+                                                 GLuint xfb,
+                                                 GLenum pname,
+                                                 GLint *param);
+angle::CallCapture CaptureGetVertexArrayIndexed64iv(const State &glState,
+                                                    bool isCallValid,
+                                                    VertexArrayID vaobjPacked,
+                                                    GLuint index,
+                                                    GLenum pname,
+                                                    GLint64 *param);
+angle::CallCapture CaptureGetVertexArrayIndexediv(const State &glState,
+                                                  bool isCallValid,
+                                                  VertexArrayID vaobjPacked,
+                                                  GLuint index,
+                                                  GLenum pname,
+                                                  GLint *param);
+angle::CallCapture CaptureGetVertexArrayiv(const State &glState,
+                                           bool isCallValid,
+                                           VertexArrayID vaobjPacked,
+                                           GLenum pname,
+                                           GLint *param);
+angle::CallCapture CaptureGetnColorTable(const State &glState,
+                                         bool isCallValid,
+                                         GLenum target,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         void *table);
+angle::CallCapture CaptureGetnCompressedTexImage(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum target,
+                                                 GLint lod,
+                                                 GLsizei bufSize,
+                                                 void *pixels);
+angle::CallCapture CaptureGetnConvolutionFilter(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLenum format,
+                                                GLenum type,
+                                                GLsizei bufSize,
+                                                void *image);
+angle::CallCapture CaptureGetnHistogram(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLboolean reset,
+                                        GLenum format,
+                                        GLenum type,
+                                        GLsizei bufSize,
+                                        void *values);
+angle::CallCapture CaptureGetnMapdv(const State &glState,
+                                    bool isCallValid,
+                                    GLenum target,
+                                    GLenum query,
+                                    GLsizei bufSize,
+                                    GLdouble *v);
+angle::CallCapture CaptureGetnMapfv(const State &glState,
+                                    bool isCallValid,
+                                    GLenum target,
+                                    GLenum query,
+                                    GLsizei bufSize,
+                                    GLfloat *v);
+angle::CallCapture CaptureGetnMapiv(const State &glState,
+                                    bool isCallValid,
+                                    GLenum target,
+                                    GLenum query,
+                                    GLsizei bufSize,
+                                    GLint *v);
+angle::CallCapture CaptureGetnMinmax(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLboolean reset,
+                                     GLenum format,
+                                     GLenum type,
+                                     GLsizei bufSize,
+                                     void *values);
+angle::CallCapture CaptureGetnPixelMapfv(const State &glState,
+                                         bool isCallValid,
+                                         GLenum map,
+                                         GLsizei bufSize,
+                                         GLfloat *values);
+angle::CallCapture CaptureGetnPixelMapuiv(const State &glState,
+                                          bool isCallValid,
+                                          GLenum map,
+                                          GLsizei bufSize,
+                                          GLuint *values);
+angle::CallCapture CaptureGetnPixelMapusv(const State &glState,
+                                          bool isCallValid,
+                                          GLenum map,
+                                          GLsizei bufSize,
+                                          GLushort *values);
+angle::CallCapture CaptureGetnPolygonStipple(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei bufSize,
+                                             GLubyte *pattern);
+angle::CallCapture CaptureGetnSeparableFilter(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              GLenum format,
+                                              GLenum type,
+                                              GLsizei rowBufSize,
+                                              void *row,
+                                              GLsizei columnBufSize,
+                                              void *column,
+                                              void *span);
+angle::CallCapture CaptureGetnTexImage(const State &glState,
+                                       bool isCallValid,
+                                       GLenum target,
+                                       GLint level,
+                                       GLenum format,
+                                       GLenum type,
+                                       GLsizei bufSize,
+                                       void *pixels);
+angle::CallCapture CaptureGetnUniformdv(const State &glState,
+                                        bool isCallValid,
+                                        ShaderProgramID programPacked,
+                                        UniformLocation locationPacked,
+                                        GLsizei bufSize,
+                                        GLdouble *params);
+angle::CallCapture CaptureInvalidateNamedFramebufferData(const State &glState,
+                                                         bool isCallValid,
+                                                         FramebufferID framebufferPacked,
+                                                         GLsizei numAttachments,
+                                                         const GLenum *attachments);
+angle::CallCapture CaptureInvalidateNamedFramebufferSubData(const State &glState,
+                                                            bool isCallValid,
+                                                            FramebufferID framebufferPacked,
+                                                            GLsizei numAttachments,
+                                                            const GLenum *attachments,
+                                                            GLint x,
+                                                            GLint y,
+                                                            GLsizei width,
+                                                            GLsizei height);
+angle::CallCapture CaptureMapNamedBuffer(const State &glState,
+                                         bool isCallValid,
+                                         BufferID bufferPacked,
+                                         GLenum access,
+                                         void *returnValue);
+angle::CallCapture CaptureMapNamedBufferRange(const State &glState,
+                                              bool isCallValid,
+                                              BufferID bufferPacked,
+                                              GLintptr offset,
+                                              GLsizeiptr length,
+                                              GLbitfield access,
+                                              void *returnValue);
+angle::CallCapture CaptureNamedBufferData(const State &glState,
+                                          bool isCallValid,
+                                          BufferID bufferPacked,
+                                          GLsizeiptr size,
+                                          const void *data,
+                                          GLenum usage);
+angle::CallCapture CaptureNamedBufferStorage(const State &glState,
+                                             bool isCallValid,
+                                             BufferID bufferPacked,
+                                             GLsizeiptr size,
+                                             const void *data,
+                                             GLbitfield flags);
+angle::CallCapture CaptureNamedBufferSubData(const State &glState,
+                                             bool isCallValid,
+                                             BufferID bufferPacked,
+                                             GLintptr offset,
+                                             GLsizeiptr size,
+                                             const void *data);
+angle::CallCapture CaptureNamedFramebufferDrawBuffer(const State &glState,
+                                                     bool isCallValid,
+                                                     FramebufferID framebufferPacked,
+                                                     GLenum buf);
+angle::CallCapture CaptureNamedFramebufferDrawBuffers(const State &glState,
+                                                      bool isCallValid,
+                                                      FramebufferID framebufferPacked,
+                                                      GLsizei n,
+                                                      const GLenum *bufs);
+angle::CallCapture CaptureNamedFramebufferParameteri(const State &glState,
+                                                     bool isCallValid,
+                                                     FramebufferID framebufferPacked,
+                                                     GLenum pname,
+                                                     GLint param);
+angle::CallCapture CaptureNamedFramebufferReadBuffer(const State &glState,
+                                                     bool isCallValid,
+                                                     FramebufferID framebufferPacked,
+                                                     GLenum src);
+angle::CallCapture CaptureNamedFramebufferRenderbuffer(const State &glState,
+                                                       bool isCallValid,
+                                                       FramebufferID framebufferPacked,
+                                                       GLenum attachment,
+                                                       GLenum renderbuffertarget,
+                                                       RenderbufferID renderbufferPacked);
+angle::CallCapture CaptureNamedFramebufferTexture(const State &glState,
+                                                  bool isCallValid,
+                                                  FramebufferID framebufferPacked,
+                                                  GLenum attachment,
+                                                  TextureID texturePacked,
+                                                  GLint level);
+angle::CallCapture CaptureNamedFramebufferTextureLayer(const State &glState,
+                                                       bool isCallValid,
+                                                       FramebufferID framebufferPacked,
+                                                       GLenum attachment,
+                                                       TextureID texturePacked,
+                                                       GLint level,
+                                                       GLint layer);
+angle::CallCapture CaptureNamedRenderbufferStorage(const State &glState,
+                                                   bool isCallValid,
+                                                   RenderbufferID renderbufferPacked,
+                                                   GLenum internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height);
+angle::CallCapture CaptureNamedRenderbufferStorageMultisample(const State &glState,
+                                                              bool isCallValid,
+                                                              RenderbufferID renderbufferPacked,
+                                                              GLsizei samples,
+                                                              GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height);
+angle::CallCapture CaptureTextureBarrier(const State &glState, bool isCallValid);
+angle::CallCapture CaptureTextureBuffer(const State &glState,
+                                        bool isCallValid,
+                                        TextureID texturePacked,
+                                        GLenum internalformat,
+                                        BufferID bufferPacked);
+angle::CallCapture CaptureTextureBufferRange(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             GLenum internalformat,
+                                             BufferID bufferPacked,
+                                             GLintptr offset,
+                                             GLsizeiptr size);
+angle::CallCapture CaptureTextureParameterIiv(const State &glState,
+                                              bool isCallValid,
+                                              TextureID texturePacked,
+                                              GLenum pname,
+                                              const GLint *params);
+angle::CallCapture CaptureTextureParameterIuiv(const State &glState,
+                                               bool isCallValid,
+                                               TextureID texturePacked,
+                                               GLenum pname,
+                                               const GLuint *params);
+angle::CallCapture CaptureTextureParameterf(const State &glState,
+                                            bool isCallValid,
+                                            TextureID texturePacked,
+                                            GLenum pname,
+                                            GLfloat param);
+angle::CallCapture CaptureTextureParameterfv(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             GLenum pname,
+                                             const GLfloat *param);
+angle::CallCapture CaptureTextureParameteri(const State &glState,
+                                            bool isCallValid,
+                                            TextureID texturePacked,
+                                            GLenum pname,
+                                            GLint param);
+angle::CallCapture CaptureTextureParameteriv(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             GLenum pname,
+                                             const GLint *param);
+angle::CallCapture CaptureTextureStorage1D(const State &glState,
+                                           bool isCallValid,
+                                           TextureID texturePacked,
+                                           GLsizei levels,
+                                           GLenum internalformat,
+                                           GLsizei width);
+angle::CallCapture CaptureTextureStorage2D(const State &glState,
+                                           bool isCallValid,
+                                           TextureID texturePacked,
+                                           GLsizei levels,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height);
+angle::CallCapture CaptureTextureStorage2DMultisample(const State &glState,
+                                                      bool isCallValid,
+                                                      TextureID texturePacked,
+                                                      GLsizei samples,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLboolean fixedsamplelocations);
+angle::CallCapture CaptureTextureStorage3D(const State &glState,
+                                           bool isCallValid,
+                                           TextureID texturePacked,
+                                           GLsizei levels,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth);
+angle::CallCapture CaptureTextureStorage3DMultisample(const State &glState,
+                                                      bool isCallValid,
+                                                      TextureID texturePacked,
+                                                      GLsizei samples,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLsizei depth,
+                                                      GLboolean fixedsamplelocations);
+angle::CallCapture CaptureTextureSubImage1D(const State &glState,
+                                            bool isCallValid,
+                                            TextureID texturePacked,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLsizei width,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void *pixels);
+angle::CallCapture CaptureTextureSubImage2D(const State &glState,
+                                            bool isCallValid,
+                                            TextureID texturePacked,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void *pixels);
+angle::CallCapture CaptureTextureSubImage3D(const State &glState,
+                                            bool isCallValid,
+                                            TextureID texturePacked,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void *pixels);
+angle::CallCapture CaptureTransformFeedbackBufferBase(const State &glState,
+                                                      bool isCallValid,
+                                                      GLuint xfb,
+                                                      GLuint index,
+                                                      BufferID bufferPacked);
+angle::CallCapture CaptureTransformFeedbackBufferRange(const State &glState,
+                                                       bool isCallValid,
+                                                       GLuint xfb,
+                                                       GLuint index,
+                                                       BufferID bufferPacked,
+                                                       GLintptr offset,
+                                                       GLsizeiptr size);
+angle::CallCapture CaptureUnmapNamedBuffer(const State &glState,
+                                           bool isCallValid,
+                                           BufferID bufferPacked,
+                                           GLboolean returnValue);
+angle::CallCapture CaptureVertexArrayAttribBinding(const State &glState,
+                                                   bool isCallValid,
+                                                   VertexArrayID vaobjPacked,
+                                                   GLuint attribindex,
+                                                   GLuint bindingindex);
+angle::CallCapture CaptureVertexArrayAttribFormat(const State &glState,
+                                                  bool isCallValid,
+                                                  VertexArrayID vaobjPacked,
+                                                  GLuint attribindex,
+                                                  GLint size,
+                                                  GLenum type,
+                                                  GLboolean normalized,
+                                                  GLuint relativeoffset);
+angle::CallCapture CaptureVertexArrayAttribIFormat(const State &glState,
+                                                   bool isCallValid,
+                                                   VertexArrayID vaobjPacked,
+                                                   GLuint attribindex,
+                                                   GLint size,
+                                                   GLenum type,
+                                                   GLuint relativeoffset);
+angle::CallCapture CaptureVertexArrayAttribLFormat(const State &glState,
+                                                   bool isCallValid,
+                                                   VertexArrayID vaobjPacked,
+                                                   GLuint attribindex,
+                                                   GLint size,
+                                                   GLenum type,
+                                                   GLuint relativeoffset);
+angle::CallCapture CaptureVertexArrayBindingDivisor(const State &glState,
+                                                    bool isCallValid,
+                                                    VertexArrayID vaobjPacked,
+                                                    GLuint bindingindex,
+                                                    GLuint divisor);
+angle::CallCapture CaptureVertexArrayElementBuffer(const State &glState,
+                                                   bool isCallValid,
+                                                   VertexArrayID vaobjPacked,
+                                                   BufferID bufferPacked);
+angle::CallCapture CaptureVertexArrayVertexBuffer(const State &glState,
+                                                  bool isCallValid,
+                                                  VertexArrayID vaobjPacked,
+                                                  GLuint bindingindex,
+                                                  BufferID bufferPacked,
+                                                  GLintptr offset,
+                                                  GLsizei stride);
+angle::CallCapture CaptureVertexArrayVertexBuffers(const State &glState,
+                                                   bool isCallValid,
+                                                   VertexArrayID vaobjPacked,
+                                                   GLuint first,
+                                                   GLsizei count,
+                                                   const BufferID *buffersPacked,
+                                                   const GLintptr *offsets,
+                                                   const GLsizei *strides);
+
+// GL 4.6
+angle::CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState,
+                                                       bool isCallValid,
+                                                       GLenum mode,
+                                                       const void *indirect,
+                                                       GLintptr drawcount,
+                                                       GLsizei maxdrawcount,
+                                                       GLsizei stride);
+angle::CallCapture CaptureMultiDrawElementsIndirectCount(const State &glState,
+                                                         bool isCallValid,
+                                                         GLenum mode,
+                                                         GLenum type,
+                                                         const void *indirect,
+                                                         GLintptr drawcount,
+                                                         GLsizei maxdrawcount,
+                                                         GLsizei stride);
+angle::CallCapture CapturePolygonOffsetClamp(const State &glState,
+                                             bool isCallValid,
+                                             GLfloat factor,
+                                             GLfloat units,
+                                             GLfloat clamp);
+angle::CallCapture CaptureSpecializeShader(const State &glState,
+                                           bool isCallValid,
+                                           GLuint shader,
+                                           const GLchar *pEntryPoint,
+                                           GLuint numSpecializationConstants,
+                                           const GLuint *pConstantIndex,
+                                           const GLuint *pConstantValue);
+
+// Parameter Captures
+
+// GL 4.0
+void CaptureGetActiveSubroutineName_length(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           GLenum shadertype,
+                                           GLuint index,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLchar *name,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetActiveSubroutineName_name(const State &glState,
+                                         bool isCallValid,
+                                         ShaderProgramID programPacked,
+                                         GLenum shadertype,
+                                         GLuint index,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLchar *name,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetActiveSubroutineUniformName_length(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  GLenum shadertype,
+                                                  GLuint index,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLchar *name,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetActiveSubroutineUniformName_name(const State &glState,
+                                                bool isCallValid,
+                                                ShaderProgramID programPacked,
+                                                GLenum shadertype,
+                                                GLuint index,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLchar *name,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetActiveSubroutineUniformiv_values(const State &glState,
+                                                bool isCallValid,
+                                                ShaderProgramID programPacked,
+                                                GLenum shadertype,
+                                                GLuint index,
+                                                GLenum pname,
+                                                GLint *values,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetProgramStageiv_values(const State &glState,
+                                     bool isCallValid,
+                                     ShaderProgramID programPacked,
+                                     GLenum shadertype,
+                                     GLenum pname,
+                                     GLint *values,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetQueryIndexediv_params(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLuint index,
+                                     GLenum pname,
+                                     GLint *params,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetSubroutineIndex_name(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    GLenum shadertype,
+                                    const GLchar *name,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetSubroutineUniformLocation_name(const State &glState,
+                                              bool isCallValid,
+                                              ShaderProgramID programPacked,
+                                              GLenum shadertype,
+                                              const GLchar *name,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetUniformSubroutineuiv_params(const State &glState,
+                                           bool isCallValid,
+                                           GLenum shadertype,
+                                           GLint location,
+                                           GLuint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetUniformdv_params(const State &glState,
+                                bool isCallValid,
+                                ShaderProgramID programPacked,
+                                UniformLocation locationPacked,
+                                GLdouble *params,
+                                angle::ParamCapture *paramCapture);
+void CapturePatchParameterfv_values(const State &glState,
+                                    bool isCallValid,
+                                    GLenum pname,
+                                    const GLfloat *values,
+                                    angle::ParamCapture *paramCapture);
+void CaptureUniform1dv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLdouble *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform2dv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLdouble *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform3dv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLdouble *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniform4dv_value(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLsizei count,
+                             const GLdouble *value,
+                             angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix2dv_value(const State &glState,
+                                   bool isCallValid,
+                                   UniformLocation locationPacked,
+                                   GLsizei count,
+                                   GLboolean transpose,
+                                   const GLdouble *value,
+                                   angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix2x3dv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLdouble *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix2x4dv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLdouble *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix3dv_value(const State &glState,
+                                   bool isCallValid,
+                                   UniformLocation locationPacked,
+                                   GLsizei count,
+                                   GLboolean transpose,
+                                   const GLdouble *value,
+                                   angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix3x2dv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLdouble *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix3x4dv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLdouble *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix4dv_value(const State &glState,
+                                   bool isCallValid,
+                                   UniformLocation locationPacked,
+                                   GLsizei count,
+                                   GLboolean transpose,
+                                   const GLdouble *value,
+                                   angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix4x2dv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLdouble *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformMatrix4x3dv_value(const State &glState,
+                                     bool isCallValid,
+                                     UniformLocation locationPacked,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLdouble *value,
+                                     angle::ParamCapture *paramCapture);
+void CaptureUniformSubroutinesuiv_indices(const State &glState,
+                                          bool isCallValid,
+                                          GLenum shadertype,
+                                          GLsizei count,
+                                          const GLuint *indices,
+                                          angle::ParamCapture *paramCapture);
+
+// GL 4.1
+void CaptureDepthRangeArrayv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint first,
+                               GLsizei count,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureGetDoublei_v_data(const State &glState,
+                              bool isCallValid,
+                              GLenum target,
+                              GLuint index,
+                              GLdouble *data,
+                              angle::ParamCapture *paramCapture);
+void CaptureGetFloati_v_data(const State &glState,
+                             bool isCallValid,
+                             GLenum target,
+                             GLuint index,
+                             GLfloat *data,
+                             angle::ParamCapture *paramCapture);
+void CaptureGetVertexAttribLdv_params(const State &glState,
+                                      bool isCallValid,
+                                      GLuint index,
+                                      GLenum pname,
+                                      GLdouble *params,
+                                      angle::ParamCapture *paramCapture);
+void CaptureProgramUniform1dv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLdouble *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform2dv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLdouble *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform3dv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLdouble *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniform4dv_value(const State &glState,
+                                    bool isCallValid,
+                                    ShaderProgramID programPacked,
+                                    UniformLocation locationPacked,
+                                    GLsizei count,
+                                    const GLdouble *value,
+                                    angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2dv_value(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          UniformLocation locationPacked,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const GLdouble *value,
+                                          angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2x3dv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLdouble *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix2x4dv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLdouble *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3dv_value(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          UniformLocation locationPacked,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const GLdouble *value,
+                                          angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3x2dv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLdouble *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix3x4dv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLdouble *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4dv_value(const State &glState,
+                                          bool isCallValid,
+                                          ShaderProgramID programPacked,
+                                          UniformLocation locationPacked,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const GLdouble *value,
+                                          angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4x2dv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLdouble *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureProgramUniformMatrix4x3dv_value(const State &glState,
+                                            bool isCallValid,
+                                            ShaderProgramID programPacked,
+                                            UniformLocation locationPacked,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLdouble *value,
+                                            angle::ParamCapture *paramCapture);
+void CaptureScissorArrayv_v(const State &glState,
+                            bool isCallValid,
+                            GLuint first,
+                            GLsizei count,
+                            const GLint *v,
+                            angle::ParamCapture *paramCapture);
+void CaptureScissorIndexedv_v(const State &glState,
+                              bool isCallValid,
+                              GLuint index,
+                              const GLint *v,
+                              angle::ParamCapture *paramCapture);
+void CaptureVertexAttribL1dv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribL2dv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribL3dv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribL4dv_v(const State &glState,
+                               bool isCallValid,
+                               GLuint index,
+                               const GLdouble *v,
+                               angle::ParamCapture *paramCapture);
+void CaptureVertexAttribLPointer_pointer(const State &glState,
+                                         bool isCallValid,
+                                         GLuint index,
+                                         GLint size,
+                                         GLenum type,
+                                         GLsizei stride,
+                                         const void *pointer,
+                                         angle::ParamCapture *paramCapture);
+void CaptureViewportArrayv_v(const State &glState,
+                             bool isCallValid,
+                             GLuint first,
+                             GLsizei count,
+                             const GLfloat *v,
+                             angle::ParamCapture *paramCapture);
+void CaptureViewportIndexedfv_v(const State &glState,
+                                bool isCallValid,
+                                GLuint index,
+                                const GLfloat *v,
+                                angle::ParamCapture *paramCapture);
+
+// GL 4.2
+void CaptureDrawElementsInstancedBaseInstance_indices(const State &glState,
+                                                      bool isCallValid,
+                                                      PrimitiveMode modePacked,
+                                                      GLsizei count,
+                                                      DrawElementsType typePacked,
+                                                      const void *indices,
+                                                      GLsizei instancecount,
+                                                      GLuint baseinstance,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedBaseVertexBaseInstance_indices(const State &glState,
+                                                                bool isCallValid,
+                                                                PrimitiveMode modePacked,
+                                                                GLsizei count,
+                                                                DrawElementsType typePacked,
+                                                                const void *indices,
+                                                                GLsizei instancecount,
+                                                                GLint basevertex,
+                                                                GLuint baseinstance,
+                                                                angle::ParamCapture *paramCapture);
+void CaptureGetActiveAtomicCounterBufferiv_params(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  GLuint bufferIndex,
+                                                  GLenum pname,
+                                                  GLint *params,
+                                                  angle::ParamCapture *paramCapture);
+
+// GL 4.3
+void CaptureClearBufferData_data(const State &glState,
+                                 bool isCallValid,
+                                 GLenum target,
+                                 GLenum internalformat,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void *data,
+                                 angle::ParamCapture *paramCapture);
+void CaptureClearBufferSubData_data(const State &glState,
+                                    bool isCallValid,
+                                    GLenum target,
+                                    GLenum internalformat,
+                                    GLintptr offset,
+                                    GLsizeiptr size,
+                                    GLenum format,
+                                    GLenum type,
+                                    const void *data,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetInternalformati64v_params(const State &glState,
+                                         bool isCallValid,
+                                         GLenum target,
+                                         GLenum internalformat,
+                                         GLenum pname,
+                                         GLsizei count,
+                                         GLint64 *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetProgramResourceLocationIndex_name(const State &glState,
+                                                 bool isCallValid,
+                                                 ShaderProgramID programPacked,
+                                                 GLenum programInterface,
+                                                 const GLchar *name,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureMultiDrawArraysIndirect_indirect(const State &glState,
+                                             bool isCallValid,
+                                             PrimitiveMode modePacked,
+                                             const void *indirect,
+                                             GLsizei drawcount,
+                                             GLsizei stride,
+                                             angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsIndirect_indirect(const State &glState,
+                                               bool isCallValid,
+                                               PrimitiveMode modePacked,
+                                               DrawElementsType typePacked,
+                                               const void *indirect,
+                                               GLsizei drawcount,
+                                               GLsizei stride,
+                                               angle::ParamCapture *paramCapture);
+
+// GL 4.4
+void CaptureBindBuffersBase_buffersPacked(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLuint first,
+                                          GLsizei count,
+                                          const BufferID *buffersPacked,
+                                          angle::ParamCapture *paramCapture);
+void CaptureBindBuffersRange_buffersPacked(const State &glState,
+                                           bool isCallValid,
+                                           GLenum target,
+                                           GLuint first,
+                                           GLsizei count,
+                                           const BufferID *buffersPacked,
+                                           const GLintptr *offsets,
+                                           const GLsizeiptr *sizes,
+                                           angle::ParamCapture *paramCapture);
+void CaptureBindBuffersRange_offsets(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLuint first,
+                                     GLsizei count,
+                                     const BufferID *buffersPacked,
+                                     const GLintptr *offsets,
+                                     const GLsizeiptr *sizes,
+                                     angle::ParamCapture *paramCapture);
+void CaptureBindBuffersRange_sizes(const State &glState,
+                                   bool isCallValid,
+                                   GLenum target,
+                                   GLuint first,
+                                   GLsizei count,
+                                   const BufferID *buffersPacked,
+                                   const GLintptr *offsets,
+                                   const GLsizeiptr *sizes,
+                                   angle::ParamCapture *paramCapture);
+void CaptureBindImageTextures_textures(const State &glState,
+                                       bool isCallValid,
+                                       GLuint first,
+                                       GLsizei count,
+                                       const GLuint *textures,
+                                       angle::ParamCapture *paramCapture);
+void CaptureBindSamplers_samplers(const State &glState,
+                                  bool isCallValid,
+                                  GLuint first,
+                                  GLsizei count,
+                                  const GLuint *samplers,
+                                  angle::ParamCapture *paramCapture);
+void CaptureBindTextures_textures(const State &glState,
+                                  bool isCallValid,
+                                  GLuint first,
+                                  GLsizei count,
+                                  const GLuint *textures,
+                                  angle::ParamCapture *paramCapture);
+void CaptureBindVertexBuffers_buffersPacked(const State &glState,
+                                            bool isCallValid,
+                                            GLuint first,
+                                            GLsizei count,
+                                            const BufferID *buffersPacked,
+                                            const GLintptr *offsets,
+                                            const GLsizei *strides,
+                                            angle::ParamCapture *paramCapture);
+void CaptureBindVertexBuffers_offsets(const State &glState,
+                                      bool isCallValid,
+                                      GLuint first,
+                                      GLsizei count,
+                                      const BufferID *buffersPacked,
+                                      const GLintptr *offsets,
+                                      const GLsizei *strides,
+                                      angle::ParamCapture *paramCapture);
+void CaptureBindVertexBuffers_strides(const State &glState,
+                                      bool isCallValid,
+                                      GLuint first,
+                                      GLsizei count,
+                                      const BufferID *buffersPacked,
+                                      const GLintptr *offsets,
+                                      const GLsizei *strides,
+                                      angle::ParamCapture *paramCapture);
+void CaptureBufferStorage_data(const State &glState,
+                               bool isCallValid,
+                               BufferBinding targetPacked,
+                               GLsizeiptr size,
+                               const void *data,
+                               GLbitfield flags,
+                               angle::ParamCapture *paramCapture);
+void CaptureClearTexImage_data(const State &glState,
+                               bool isCallValid,
+                               TextureID texturePacked,
+                               GLint level,
+                               GLenum format,
+                               GLenum type,
+                               const void *data,
+                               angle::ParamCapture *paramCapture);
+void CaptureClearTexSubImage_data(const State &glState,
+                                  bool isCallValid,
+                                  TextureID texturePacked,
+                                  GLint level,
+                                  GLint xoffset,
+                                  GLint yoffset,
+                                  GLint zoffset,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLsizei depth,
+                                  GLenum format,
+                                  GLenum type,
+                                  const void *data,
+                                  angle::ParamCapture *paramCapture);
+
+// GL 4.5
+void CaptureClearNamedBufferData_data(const State &glState,
+                                      bool isCallValid,
+                                      BufferID bufferPacked,
+                                      GLenum internalformat,
+                                      GLenum format,
+                                      GLenum type,
+                                      const void *data,
+                                      angle::ParamCapture *paramCapture);
+void CaptureClearNamedBufferSubData_data(const State &glState,
+                                         bool isCallValid,
+                                         BufferID bufferPacked,
+                                         GLenum internalformat,
+                                         GLintptr offset,
+                                         GLsizeiptr size,
+                                         GLenum format,
+                                         GLenum type,
+                                         const void *data,
+                                         angle::ParamCapture *paramCapture);
+void CaptureClearNamedFramebufferfv_value(const State &glState,
+                                          bool isCallValid,
+                                          FramebufferID framebufferPacked,
+                                          GLenum buffer,
+                                          GLint drawbuffer,
+                                          const GLfloat *value,
+                                          angle::ParamCapture *paramCapture);
+void CaptureClearNamedFramebufferiv_value(const State &glState,
+                                          bool isCallValid,
+                                          FramebufferID framebufferPacked,
+                                          GLenum buffer,
+                                          GLint drawbuffer,
+                                          const GLint *value,
+                                          angle::ParamCapture *paramCapture);
+void CaptureClearNamedFramebufferuiv_value(const State &glState,
+                                           bool isCallValid,
+                                           FramebufferID framebufferPacked,
+                                           GLenum buffer,
+                                           GLint drawbuffer,
+                                           const GLuint *value,
+                                           angle::ParamCapture *paramCapture);
+void CaptureCompressedTextureSubImage1D_data(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLsizei width,
+                                             GLenum format,
+                                             GLsizei imageSize,
+                                             const void *data,
+                                             angle::ParamCapture *paramCapture);
+void CaptureCompressedTextureSubImage2D_data(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLint yoffset,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLenum format,
+                                             GLsizei imageSize,
+                                             const void *data,
+                                             angle::ParamCapture *paramCapture);
+void CaptureCompressedTextureSubImage3D_data(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             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 CaptureCreateBuffers_buffersPacked(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        BufferID *buffersPacked,
+                                        angle::ParamCapture *paramCapture);
+void CaptureCreateFramebuffers_framebuffers(const State &glState,
+                                            bool isCallValid,
+                                            GLsizei n,
+                                            GLuint *framebuffers,
+                                            angle::ParamCapture *paramCapture);
+void CaptureCreateProgramPipelines_pipelines(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             GLuint *pipelines,
+                                             angle::ParamCapture *paramCapture);
+void CaptureCreateQueries_ids(const State &glState,
+                              bool isCallValid,
+                              GLenum target,
+                              GLsizei n,
+                              GLuint *ids,
+                              angle::ParamCapture *paramCapture);
+void CaptureCreateRenderbuffers_renderbuffersPacked(const State &glState,
+                                                    bool isCallValid,
+                                                    GLsizei n,
+                                                    RenderbufferID *renderbuffersPacked,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureCreateSamplers_samplers(const State &glState,
+                                    bool isCallValid,
+                                    GLsizei n,
+                                    GLuint *samplers,
+                                    angle::ParamCapture *paramCapture);
+void CaptureCreateTextures_textures(const State &glState,
+                                    bool isCallValid,
+                                    GLenum target,
+                                    GLsizei n,
+                                    GLuint *textures,
+                                    angle::ParamCapture *paramCapture);
+void CaptureCreateTransformFeedbacks_ids(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei n,
+                                         GLuint *ids,
+                                         angle::ParamCapture *paramCapture);
+void CaptureCreateVertexArrays_arraysPacked(const State &glState,
+                                            bool isCallValid,
+                                            GLsizei n,
+                                            VertexArrayID *arraysPacked,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetCompressedTextureImage_pixels(const State &glState,
+                                             bool isCallValid,
+                                             TextureID texturePacked,
+                                             GLint level,
+                                             GLsizei bufSize,
+                                             void *pixels,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetCompressedTextureSubImage_pixels(const State &glState,
+                                                bool isCallValid,
+                                                TextureID texturePacked,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint zoffset,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLsizei depth,
+                                                GLsizei bufSize,
+                                                void *pixels,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetNamedBufferParameteri64v_params(const State &glState,
+                                               bool isCallValid,
+                                               BufferID bufferPacked,
+                                               GLenum pname,
+                                               GLint64 *params,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetNamedBufferParameteriv_params(const State &glState,
+                                             bool isCallValid,
+                                             BufferID bufferPacked,
+                                             GLenum pname,
+                                             GLint *params,
+                                             angle::ParamCapture *paramCapture);
+void CaptureGetNamedBufferPointerv_params(const State &glState,
+                                          bool isCallValid,
+                                          BufferID bufferPacked,
+                                          GLenum pname,
+                                          void **params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetNamedBufferSubData_data(const State &glState,
+                                       bool isCallValid,
+                                       BufferID bufferPacked,
+                                       GLintptr offset,
+                                       GLsizeiptr size,
+                                       void *data,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetNamedFramebufferAttachmentParameteriv_params(const State &glState,
+                                                            bool isCallValid,
+                                                            FramebufferID framebufferPacked,
+                                                            GLenum attachment,
+                                                            GLenum pname,
+                                                            GLint *params,
+                                                            angle::ParamCapture *paramCapture);
+void CaptureGetNamedFramebufferParameteriv_param(const State &glState,
+                                                 bool isCallValid,
+                                                 FramebufferID framebufferPacked,
+                                                 GLenum pname,
+                                                 GLint *param,
+                                                 angle::ParamCapture *paramCapture);
+void CaptureGetNamedRenderbufferParameteriv_params(const State &glState,
+                                                   bool isCallValid,
+                                                   RenderbufferID renderbufferPacked,
+                                                   GLenum pname,
+                                                   GLint *params,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureGetTextureImage_pixels(const State &glState,
+                                   bool isCallValid,
+                                   TextureID texturePacked,
+                                   GLint level,
+                                   GLenum format,
+                                   GLenum type,
+                                   GLsizei bufSize,
+                                   void *pixels,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetTextureLevelParameterfv_params(const State &glState,
+                                              bool isCallValid,
+                                              TextureID texturePacked,
+                                              GLint level,
+                                              GLenum pname,
+                                              GLfloat *params,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetTextureLevelParameteriv_params(const State &glState,
+                                              bool isCallValid,
+                                              TextureID texturePacked,
+                                              GLint level,
+                                              GLenum pname,
+                                              GLint *params,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetTextureParameterIiv_params(const State &glState,
+                                          bool isCallValid,
+                                          TextureID texturePacked,
+                                          GLenum pname,
+                                          GLint *params,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetTextureParameterIuiv_params(const State &glState,
+                                           bool isCallValid,
+                                           TextureID texturePacked,
+                                           GLenum pname,
+                                           GLuint *params,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGetTextureParameterfv_params(const State &glState,
+                                         bool isCallValid,
+                                         TextureID texturePacked,
+                                         GLenum pname,
+                                         GLfloat *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetTextureParameteriv_params(const State &glState,
+                                         bool isCallValid,
+                                         TextureID texturePacked,
+                                         GLenum pname,
+                                         GLint *params,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetTextureSubImage_pixels(const State &glState,
+                                      bool isCallValid,
+                                      TextureID texturePacked,
+                                      GLint level,
+                                      GLint xoffset,
+                                      GLint yoffset,
+                                      GLint zoffset,
+                                      GLsizei width,
+                                      GLsizei height,
+                                      GLsizei depth,
+                                      GLenum format,
+                                      GLenum type,
+                                      GLsizei bufSize,
+                                      void *pixels,
+                                      angle::ParamCapture *paramCapture);
+void CaptureGetTransformFeedbacki64_v_param(const State &glState,
+                                            bool isCallValid,
+                                            GLuint xfb,
+                                            GLenum pname,
+                                            GLuint index,
+                                            GLint64 *param,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetTransformFeedbacki_v_param(const State &glState,
+                                          bool isCallValid,
+                                          GLuint xfb,
+                                          GLenum pname,
+                                          GLuint index,
+                                          GLint *param,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetTransformFeedbackiv_param(const State &glState,
+                                         bool isCallValid,
+                                         GLuint xfb,
+                                         GLenum pname,
+                                         GLint *param,
+                                         angle::ParamCapture *paramCapture);
+void CaptureGetVertexArrayIndexed64iv_param(const State &glState,
+                                            bool isCallValid,
+                                            VertexArrayID vaobjPacked,
+                                            GLuint index,
+                                            GLenum pname,
+                                            GLint64 *param,
+                                            angle::ParamCapture *paramCapture);
+void CaptureGetVertexArrayIndexediv_param(const State &glState,
+                                          bool isCallValid,
+                                          VertexArrayID vaobjPacked,
+                                          GLuint index,
+                                          GLenum pname,
+                                          GLint *param,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetVertexArrayiv_param(const State &glState,
+                                   bool isCallValid,
+                                   VertexArrayID vaobjPacked,
+                                   GLenum pname,
+                                   GLint *param,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetnColorTable_table(const State &glState,
+                                 bool isCallValid,
+                                 GLenum target,
+                                 GLenum format,
+                                 GLenum type,
+                                 GLsizei bufSize,
+                                 void *table,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetnCompressedTexImage_pixels(const State &glState,
+                                          bool isCallValid,
+                                          GLenum target,
+                                          GLint lod,
+                                          GLsizei bufSize,
+                                          void *pixels,
+                                          angle::ParamCapture *paramCapture);
+void CaptureGetnConvolutionFilter_image(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLenum format,
+                                        GLenum type,
+                                        GLsizei bufSize,
+                                        void *image,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetnHistogram_values(const State &glState,
+                                 bool isCallValid,
+                                 GLenum target,
+                                 GLboolean reset,
+                                 GLenum format,
+                                 GLenum type,
+                                 GLsizei bufSize,
+                                 void *values,
+                                 angle::ParamCapture *paramCapture);
+void CaptureGetnMapdv_v(const State &glState,
+                        bool isCallValid,
+                        GLenum target,
+                        GLenum query,
+                        GLsizei bufSize,
+                        GLdouble *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureGetnMapfv_v(const State &glState,
+                        bool isCallValid,
+                        GLenum target,
+                        GLenum query,
+                        GLsizei bufSize,
+                        GLfloat *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureGetnMapiv_v(const State &glState,
+                        bool isCallValid,
+                        GLenum target,
+                        GLenum query,
+                        GLsizei bufSize,
+                        GLint *v,
+                        angle::ParamCapture *paramCapture);
+void CaptureGetnMinmax_values(const State &glState,
+                              bool isCallValid,
+                              GLenum target,
+                              GLboolean reset,
+                              GLenum format,
+                              GLenum type,
+                              GLsizei bufSize,
+                              void *values,
+                              angle::ParamCapture *paramCapture);
+void CaptureGetnPixelMapfv_values(const State &glState,
+                                  bool isCallValid,
+                                  GLenum map,
+                                  GLsizei bufSize,
+                                  GLfloat *values,
+                                  angle::ParamCapture *paramCapture);
+void CaptureGetnPixelMapuiv_values(const State &glState,
+                                   bool isCallValid,
+                                   GLenum map,
+                                   GLsizei bufSize,
+                                   GLuint *values,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetnPixelMapusv_values(const State &glState,
+                                   bool isCallValid,
+                                   GLenum map,
+                                   GLsizei bufSize,
+                                   GLushort *values,
+                                   angle::ParamCapture *paramCapture);
+void CaptureGetnPolygonStipple_pattern(const State &glState,
+                                       bool isCallValid,
+                                       GLsizei bufSize,
+                                       GLubyte *pattern,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetnSeparableFilter_row(const State &glState,
+                                    bool isCallValid,
+                                    GLenum target,
+                                    GLenum format,
+                                    GLenum type,
+                                    GLsizei rowBufSize,
+                                    void *row,
+                                    GLsizei columnBufSize,
+                                    void *column,
+                                    void *span,
+                                    angle::ParamCapture *paramCapture);
+void CaptureGetnSeparableFilter_column(const State &glState,
+                                       bool isCallValid,
+                                       GLenum target,
+                                       GLenum format,
+                                       GLenum type,
+                                       GLsizei rowBufSize,
+                                       void *row,
+                                       GLsizei columnBufSize,
+                                       void *column,
+                                       void *span,
+                                       angle::ParamCapture *paramCapture);
+void CaptureGetnSeparableFilter_span(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLenum format,
+                                     GLenum type,
+                                     GLsizei rowBufSize,
+                                     void *row,
+                                     GLsizei columnBufSize,
+                                     void *column,
+                                     void *span,
+                                     angle::ParamCapture *paramCapture);
+void CaptureGetnTexImage_pixels(const State &glState,
+                                bool isCallValid,
+                                GLenum target,
+                                GLint level,
+                                GLenum format,
+                                GLenum type,
+                                GLsizei bufSize,
+                                void *pixels,
+                                angle::ParamCapture *paramCapture);
+void CaptureGetnUniformdv_params(const State &glState,
+                                 bool isCallValid,
+                                 ShaderProgramID programPacked,
+                                 UniformLocation locationPacked,
+                                 GLsizei bufSize,
+                                 GLdouble *params,
+                                 angle::ParamCapture *paramCapture);
+void CaptureInvalidateNamedFramebufferData_attachments(const State &glState,
+                                                       bool isCallValid,
+                                                       FramebufferID framebufferPacked,
+                                                       GLsizei numAttachments,
+                                                       const GLenum *attachments,
+                                                       angle::ParamCapture *paramCapture);
+void CaptureInvalidateNamedFramebufferSubData_attachments(const State &glState,
+                                                          bool isCallValid,
+                                                          FramebufferID framebufferPacked,
+                                                          GLsizei numAttachments,
+                                                          const GLenum *attachments,
+                                                          GLint x,
+                                                          GLint y,
+                                                          GLsizei width,
+                                                          GLsizei height,
+                                                          angle::ParamCapture *paramCapture);
+void CaptureNamedBufferData_data(const State &glState,
+                                 bool isCallValid,
+                                 BufferID bufferPacked,
+                                 GLsizeiptr size,
+                                 const void *data,
+                                 GLenum usage,
+                                 angle::ParamCapture *paramCapture);
+void CaptureNamedBufferStorage_data(const State &glState,
+                                    bool isCallValid,
+                                    BufferID bufferPacked,
+                                    GLsizeiptr size,
+                                    const void *data,
+                                    GLbitfield flags,
+                                    angle::ParamCapture *paramCapture);
+void CaptureNamedBufferSubData_data(const State &glState,
+                                    bool isCallValid,
+                                    BufferID bufferPacked,
+                                    GLintptr offset,
+                                    GLsizeiptr size,
+                                    const void *data,
+                                    angle::ParamCapture *paramCapture);
+void CaptureNamedFramebufferDrawBuffers_bufs(const State &glState,
+                                             bool isCallValid,
+                                             FramebufferID framebufferPacked,
+                                             GLsizei n,
+                                             const GLenum *bufs,
+                                             angle::ParamCapture *paramCapture);
+void CaptureTextureParameterIiv_params(const State &glState,
+                                       bool isCallValid,
+                                       TextureID texturePacked,
+                                       GLenum pname,
+                                       const GLint *params,
+                                       angle::ParamCapture *paramCapture);
+void CaptureTextureParameterIuiv_params(const State &glState,
+                                        bool isCallValid,
+                                        TextureID texturePacked,
+                                        GLenum pname,
+                                        const GLuint *params,
+                                        angle::ParamCapture *paramCapture);
+void CaptureTextureParameterfv_param(const State &glState,
+                                     bool isCallValid,
+                                     TextureID texturePacked,
+                                     GLenum pname,
+                                     const GLfloat *param,
+                                     angle::ParamCapture *paramCapture);
+void CaptureTextureParameteriv_param(const State &glState,
+                                     bool isCallValid,
+                                     TextureID texturePacked,
+                                     GLenum pname,
+                                     const GLint *param,
+                                     angle::ParamCapture *paramCapture);
+void CaptureTextureSubImage1D_pixels(const State &glState,
+                                     bool isCallValid,
+                                     TextureID texturePacked,
+                                     GLint level,
+                                     GLint xoffset,
+                                     GLsizei width,
+                                     GLenum format,
+                                     GLenum type,
+                                     const void *pixels,
+                                     angle::ParamCapture *paramCapture);
+void CaptureTextureSubImage2D_pixels(const State &glState,
+                                     bool isCallValid,
+                                     TextureID texturePacked,
+                                     GLint level,
+                                     GLint xoffset,
+                                     GLint yoffset,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLenum format,
+                                     GLenum type,
+                                     const void *pixels,
+                                     angle::ParamCapture *paramCapture);
+void CaptureTextureSubImage3D_pixels(const State &glState,
+                                     bool isCallValid,
+                                     TextureID texturePacked,
+                                     GLint level,
+                                     GLint xoffset,
+                                     GLint yoffset,
+                                     GLint zoffset,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLsizei depth,
+                                     GLenum format,
+                                     GLenum type,
+                                     const void *pixels,
+                                     angle::ParamCapture *paramCapture);
+void CaptureVertexArrayVertexBuffers_buffersPacked(const State &glState,
+                                                   bool isCallValid,
+                                                   VertexArrayID vaobjPacked,
+                                                   GLuint first,
+                                                   GLsizei count,
+                                                   const BufferID *buffersPacked,
+                                                   const GLintptr *offsets,
+                                                   const GLsizei *strides,
+                                                   angle::ParamCapture *paramCapture);
+void CaptureVertexArrayVertexBuffers_offsets(const State &glState,
+                                             bool isCallValid,
+                                             VertexArrayID vaobjPacked,
+                                             GLuint first,
+                                             GLsizei count,
+                                             const BufferID *buffersPacked,
+                                             const GLintptr *offsets,
+                                             const GLsizei *strides,
+                                             angle::ParamCapture *paramCapture);
+void CaptureVertexArrayVertexBuffers_strides(const State &glState,
+                                             bool isCallValid,
+                                             VertexArrayID vaobjPacked,
+                                             GLuint first,
+                                             GLsizei count,
+                                             const BufferID *buffersPacked,
+                                             const GLintptr *offsets,
+                                             const GLsizei *strides,
+                                             angle::ParamCapture *paramCapture);
+
+// GL 4.6
+void CaptureMultiDrawArraysIndirectCount_indirect(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum mode,
+                                                  const void *indirect,
+                                                  GLintptr drawcount,
+                                                  GLsizei maxdrawcount,
+                                                  GLsizei stride,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsIndirectCount_indirect(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum mode,
+                                                    GLenum type,
+                                                    const void *indirect,
+                                                    GLintptr drawcount,
+                                                    GLsizei maxdrawcount,
+                                                    GLsizei stride,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureSpecializeShader_pEntryPoint(const State &glState,
+                                         bool isCallValid,
+                                         GLuint shader,
+                                         const GLchar *pEntryPoint,
+                                         GLuint numSpecializationConstants,
+                                         const GLuint *pConstantIndex,
+                                         const GLuint *pConstantValue,
+                                         angle::ParamCapture *paramCapture);
+void CaptureSpecializeShader_pConstantIndex(const State &glState,
+                                            bool isCallValid,
+                                            GLuint shader,
+                                            const GLchar *pEntryPoint,
+                                            GLuint numSpecializationConstants,
+                                            const GLuint *pConstantIndex,
+                                            const GLuint *pConstantValue,
+                                            angle::ParamCapture *paramCapture);
+void CaptureSpecializeShader_pConstantValue(const State &glState,
+                                            bool isCallValid,
+                                            GLuint shader,
+                                            const GLchar *pEntryPoint,
+                                            GLuint numSpecializationConstants,
+                                            const GLuint *pConstantIndex,
+                                            const GLuint *pConstantValue,
+                                            angle::ParamCapture *paramCapture);
+}  // namespace gl
+
+#endif  // LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_
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..d4d1d978a2
--- /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..83e2f441b4
--- /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 count,
+                                              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 count,
+                                    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 count,
+                                       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 count,
+                             GLsizei *length,
+                             GLint *values,
+                             angle::ParamCapture *paramCapture);
+void CaptureGetSynciv_values(const State &glState,
+                             bool isCallValid,
+                             GLsync sync,
+                             GLenum pname,
+                             GLsizei count,
+                             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..ee594a1c79
--- /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 count,
+                                               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 count,
+                                       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 count,
+                                        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 count,
+                                        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..03211ffeb9
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_ext_autogen.h
@@ -0,0 +1,5231 @@
+// 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_AMD_performance_monitor
+angle::CallCapture CaptureBeginPerfMonitorAMD(const State &glState,
+                                              bool isCallValid,
+                                              GLuint monitor);
+angle::CallCapture CaptureDeletePerfMonitorsAMD(const State &glState,
+                                                bool isCallValid,
+                                                GLsizei n,
+                                                GLuint *monitors);
+angle::CallCapture CaptureEndPerfMonitorAMD(const State &glState, bool isCallValid, GLuint monitor);
+angle::CallCapture CaptureGenPerfMonitorsAMD(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             GLuint *monitors);
+angle::CallCapture CaptureGetPerfMonitorCounterDataAMD(const State &glState,
+                                                       bool isCallValid,
+                                                       GLuint monitor,
+                                                       GLenum pname,
+                                                       GLsizei dataSize,
+                                                       GLuint *data,
+                                                       GLint *bytesWritten);
+angle::CallCapture CaptureGetPerfMonitorCounterInfoAMD(const State &glState,
+                                                       bool isCallValid,
+                                                       GLuint group,
+                                                       GLuint counter,
+                                                       GLenum pname,
+                                                       void *data);
+angle::CallCapture CaptureGetPerfMonitorCounterStringAMD(const State &glState,
+                                                         bool isCallValid,
+                                                         GLuint group,
+                                                         GLuint counter,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLchar *counterString);
+angle::CallCapture CaptureGetPerfMonitorCountersAMD(const State &glState,
+                                                    bool isCallValid,
+                                                    GLuint group,
+                                                    GLint *numCounters,
+                                                    GLint *maxActiveCounters,
+                                                    GLsizei counterSize,
+                                                    GLuint *counters);
+angle::CallCapture CaptureGetPerfMonitorGroupStringAMD(const State &glState,
+                                                       bool isCallValid,
+                                                       GLuint group,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLchar *groupString);
+angle::CallCapture CaptureGetPerfMonitorGroupsAMD(const State &glState,
+                                                  bool isCallValid,
+                                                  GLint *numGroups,
+                                                  GLsizei groupsSize,
+                                                  GLuint *groups);
+angle::CallCapture CaptureSelectPerfMonitorCountersAMD(const State &glState,
+                                                       bool isCallValid,
+                                                       GLuint monitor,
+                                                       GLboolean enable,
+                                                       GLuint group,
+                                                       GLint numCounters,
+                                                       GLuint *counterList);
+
+// GL_ANDROID_extension_pack_es31a
+
+// GL_ANGLE_base_vertex_base_instance
+angle::CallCapture CaptureDrawArraysInstancedBaseInstanceANGLE(const State &glState,
+                                                               bool isCallValid,
+                                                               PrimitiveMode modePacked,
+                                                               GLint first,
+                                                               GLsizei count,
+                                                               GLsizei instanceCount,
+                                                               GLuint baseInstance);
+angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    GLsizei count,
+    DrawElementsType typePacked,
+    const GLvoid *indices,
+    GLsizei instanceCount,
+    GLint baseVertex,
+    GLuint baseInstance);
+angle::CallCapture CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State &glState,
+                                                                    bool isCallValid,
+                                                                    PrimitiveMode modePacked,
+                                                                    const GLint *firsts,
+                                                                    const GLsizei *counts,
+                                                                    const GLsizei *instanceCounts,
+                                                                    const GLuint *baseInstances,
+                                                                    GLsizei drawcount);
+angle::CallCapture CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    const GLsizei *counts,
+    DrawElementsType typePacked,
+    const 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_depth_texture
+
+// GL_ANGLE_framebuffer_blit
+angle::CallCapture CaptureBlitFramebufferANGLE(const State &glState,
+                                               bool isCallValid,
+                                               GLint srcX0,
+                                               GLint srcY0,
+                                               GLint srcX1,
+                                               GLint srcY1,
+                                               GLint dstX0,
+                                               GLint dstY0,
+                                               GLint dstX1,
+                                               GLint dstY1,
+                                               GLbitfield mask,
+                                               GLenum filter);
+
+// GL_ANGLE_framebuffer_multisample
+angle::CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState,
+                                                              bool isCallValid,
+                                                              GLenum target,
+                                                              GLsizei samples,
+                                                              GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height);
+
+// GL_ANGLE_get_image
+angle::CallCapture CaptureGetTexImageANGLE(const State &glState,
+                                           bool isCallValid,
+                                           TextureTarget targetPacked,
+                                           GLint level,
+                                           GLenum format,
+                                           GLenum type,
+                                           void *pixels);
+angle::CallCapture CaptureGetCompressedTexImageANGLE(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureTarget targetPacked,
+                                                     GLint level,
+                                                     void *pixels);
+angle::CallCapture CaptureGetRenderbufferImageANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum target,
+                                                    GLenum format,
+                                                    GLenum type,
+                                                    void *pixels);
+
+// GL_ANGLE_get_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_logic_op
+angle::CallCapture CaptureLogicOpANGLE(const State &glState,
+                                       bool isCallValid,
+                                       LogicalOperation opcodePacked);
+
+// GL_ANGLE_memory_object_flags
+angle::CallCapture CaptureTexStorageMemFlags2DANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureType targetPacked,
+                                                    GLsizei levels,
+                                                    GLenum internalFormat,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    MemoryObjectID memoryPacked,
+                                                    GLuint64 offset,
+                                                    GLbitfield createFlags,
+                                                    GLbitfield usageFlags,
+                                                    const void *imageCreateInfoPNext);
+angle::CallCapture CaptureTexStorageMemFlags2DMultisampleANGLE(const State &glState,
+                                                               bool isCallValid,
+                                                               TextureType targetPacked,
+                                                               GLsizei samples,
+                                                               GLenum internalFormat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               GLboolean fixedSampleLocations,
+                                                               MemoryObjectID memoryPacked,
+                                                               GLuint64 offset,
+                                                               GLbitfield createFlags,
+                                                               GLbitfield usageFlags,
+                                                               const void *imageCreateInfoPNext);
+angle::CallCapture CaptureTexStorageMemFlags3DANGLE(const State &glState,
+                                                    bool isCallValid,
+                                                    TextureType targetPacked,
+                                                    GLsizei levels,
+                                                    GLenum internalFormat,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLsizei depth,
+                                                    MemoryObjectID memoryPacked,
+                                                    GLuint64 offset,
+                                                    GLbitfield createFlags,
+                                                    GLbitfield usageFlags,
+                                                    const void *imageCreateInfoPNext);
+angle::CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState,
+                                                               bool isCallValid,
+                                                               TextureType targetPacked,
+                                                               GLsizei samples,
+                                                               GLenum internalFormat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               GLsizei depth,
+                                                               GLboolean fixedSampleLocations,
+                                                               MemoryObjectID memoryPacked,
+                                                               GLuint64 offset,
+                                                               GLbitfield createFlags,
+                                                               GLbitfield usageFlags,
+                                                               const void *imageCreateInfoPNext);
+
+// GL_ANGLE_memory_object_fuchsia
+angle::CallCapture CaptureImportMemoryZirconHandleANGLE(const State &glState,
+                                                        bool isCallValid,
+                                                        MemoryObjectID memoryPacked,
+                                                        GLuint64 size,
+                                                        HandleType handleTypePacked,
+                                                        GLuint handle);
+
+// GL_ANGLE_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_pack_reverse_row_order
+
+// 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_robust_resource_initialization
+
+// GL_ANGLE_semaphore_fuchsia
+angle::CallCapture CaptureImportSemaphoreZirconHandleANGLE(const State &glState,
+                                                           bool isCallValid,
+                                                           SemaphoreID semaphorePacked,
+                                                           HandleType handleTypePacked,
+                                                           GLuint handle);
+
+// GL_ANGLE_shader_pixel_local_storage
+angle::CallCapture CaptureFramebufferMemorylessPixelLocalStorageANGLE(const State &glState,
+                                                                      bool isCallValid,
+                                                                      GLint plane,
+                                                                      GLenum internalformat);
+angle::CallCapture CaptureFramebufferTexturePixelLocalStorageANGLE(const State &glState,
+                                                                   bool isCallValid,
+                                                                   GLint plane,
+                                                                   TextureID backingtexturePacked,
+                                                                   GLint level,
+                                                                   GLint layer);
+angle::CallCapture CaptureBeginPixelLocalStorageANGLE(const State &glState,
+                                                      bool isCallValid,
+                                                      GLsizei planes,
+                                                      const GLenum *loadops,
+                                                      const void *cleardata);
+angle::CallCapture CaptureEndPixelLocalStorageANGLE(const State &glState, bool isCallValid);
+angle::CallCapture CapturePixelLocalStorageBarrierANGLE(const State &glState, bool isCallValid);
+
+// GL_ANGLE_texture_compression_dxt3
+
+// GL_ANGLE_texture_compression_dxt5
+
+// 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_texture_usage
+
+// GL_ANGLE_translated_shader_source
+angle::CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
+                                                         bool isCallValid,
+                                                         ShaderProgramID shaderPacked,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLchar *source);
+
+// GL_ANGLE_vulkan_image
+angle::CallCapture CaptureAcquireTexturesANGLE(const State &glState,
+                                               bool isCallValid,
+                                               GLuint numTextures,
+                                               const TextureID *texturesPacked,
+                                               const GLenum *layouts);
+angle::CallCapture CaptureReleaseTexturesANGLE(const State &glState,
+                                               bool isCallValid,
+                                               GLuint numTextures,
+                                               const TextureID *texturesPacked,
+                                               GLenum *layouts);
+
+// GL_APPLE_clip_distance
+
+// GL_ARB_sync
+
+// GL_CHROMIUM_bind_uniform_location
+angle::CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
+                                                      bool isCallValid,
+                                                      ShaderProgramID programPacked,
+                                                      UniformLocation locationPacked,
+                                                      const GLchar *name);
+
+// GL_CHROMIUM_copy_compressed_texture
+angle::CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState,
+                                                        bool isCallValid,
+                                                        TextureID sourceIdPacked,
+                                                        TextureID destIdPacked);
+
+// GL_CHROMIUM_copy_texture
+angle::CallCapture CaptureCopyTextureCHROMIUM(const State &glState,
+                                              bool isCallValid,
+                                              TextureID sourceIdPacked,
+                                              GLint sourceLevel,
+                                              TextureTarget destTargetPacked,
+                                              TextureID destIdPacked,
+                                              GLint destLevel,
+                                              GLint internalFormat,
+                                              GLenum destType,
+                                              GLboolean unpackFlipY,
+                                              GLboolean unpackPremultiplyAlpha,
+                                              GLboolean unpackUnmultiplyAlpha);
+angle::CallCapture CaptureCopySubTextureCHROMIUM(const State &glState,
+                                                 bool isCallValid,
+                                                 TextureID sourceIdPacked,
+                                                 GLint sourceLevel,
+                                                 TextureTarget destTargetPacked,
+                                                 TextureID destIdPacked,
+                                                 GLint destLevel,
+                                                 GLint xoffset,
+                                                 GLint yoffset,
+                                                 GLint x,
+                                                 GLint y,
+                                                 GLint width,
+                                                 GLint height,
+                                                 GLboolean unpackFlipY,
+                                                 GLboolean unpackPremultiplyAlpha,
+                                                 GLboolean unpackUnmultiplyAlpha);
+
+// GL_CHROMIUM_framebuffer_mixed_samples
+angle::CallCapture CaptureCoverageModulationCHROMIUM(const State &glState,
+                                                     bool isCallValid,
+                                                     GLenum components);
+
+// GL_CHROMIUM_lose_context
+angle::CallCapture CaptureLoseContextCHROMIUM(const State &glState,
+                                              bool isCallValid,
+                                              GraphicsResetStatus currentPacked,
+                                              GraphicsResetStatus otherPacked);
+
+// GL_EXT_EGL_image_array
+
+// GL_EXT_EGL_image_storage
+angle::CallCapture CaptureEGLImageTargetTexStorageEXT(const State &glState,
+                                                      bool isCallValid,
+                                                      GLenum target,
+                                                      GLeglImageOES image,
+                                                      const GLint *attrib_list);
+angle::CallCapture CaptureEGLImageTargetTextureStorageEXT(const State &glState,
+                                                          bool isCallValid,
+                                                          GLuint texture,
+                                                          GLeglImageOES image,
+                                                          const GLint *attrib_list);
+
+// GL_EXT_YUV_target
+
+// GL_EXT_base_instance
+angle::CallCapture CaptureDrawArraysInstancedBaseInstanceEXT(const State &glState,
+                                                             bool isCallValid,
+                                                             PrimitiveMode modePacked,
+                                                             GLint first,
+                                                             GLsizei count,
+                                                             GLsizei instancecount,
+                                                             GLuint baseinstance);
+angle::CallCapture CaptureDrawElementsInstancedBaseInstanceEXT(const State &glState,
+                                                               bool isCallValid,
+                                                               PrimitiveMode modePacked,
+                                                               GLsizei count,
+                                                               DrawElementsType typePacked,
+                                                               const void *indices,
+                                                               GLsizei instancecount,
+                                                               GLuint baseinstance);
+angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    GLsizei count,
+    DrawElementsType typePacked,
+    const void *indices,
+    GLsizei instancecount,
+    GLint basevertex,
+    GLuint baseinstance);
+
+// GL_EXT_blend_func_extended
+angle::CallCapture CaptureBindFragDataLocationEXT(const State &glState,
+                                                  bool isCallValid,
+                                                  ShaderProgramID programPacked,
+                                                  GLuint color,
+                                                  const GLchar *name);
+angle::CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState,
+                                                         bool isCallValid,
+                                                         ShaderProgramID programPacked,
+                                                         GLuint colorNumber,
+                                                         GLuint index,
+                                                         const GLchar *name);
+angle::CallCapture CaptureGetFragDataIndexEXT(const State &glState,
+                                              bool isCallValid,
+                                              ShaderProgramID programPacked,
+                                              const GLchar *name,
+                                              GLint returnValue);
+angle::CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState,
+                                                             bool isCallValid,
+                                                             ShaderProgramID programPacked,
+                                                             GLenum programInterface,
+                                                             const GLchar *name,
+                                                             GLint returnValue);
+
+// GL_EXT_blend_minmax
+
+// GL_EXT_buffer_storage
+angle::CallCapture CaptureBufferStorageEXT(const State &glState,
+                                           bool isCallValid,
+                                           BufferBinding targetPacked,
+                                           GLsizeiptr size,
+                                           const void *data,
+                                           GLbitfield flags);
+
+// GL_EXT_clip_control
+angle::CallCapture CaptureClipControlEXT(const State &glState,
+                                         bool isCallValid,
+                                         GLenum origin,
+                                         GLenum depth);
+
+// GL_EXT_clip_cull_distance
+
+// GL_EXT_color_buffer_float
+
+// GL_EXT_color_buffer_half_float
+
+// 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 drawcount,
+                                                         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_float_blend
+
+// GL_EXT_geometry_shader
+angle::CallCapture CaptureFramebufferTextureEXT(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLenum attachment,
+                                                TextureID texturePacked,
+                                                GLint level);
+
+// GL_EXT_gpu_shader5
+
+// GL_EXT_instanced_arrays
+angle::CallCapture 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_multi_draw_indirect
+angle::CallCapture CaptureMultiDrawArraysIndirectEXT(const State &glState,
+                                                     bool isCallValid,
+                                                     PrimitiveMode modePacked,
+                                                     const void *indirect,
+                                                     GLsizei drawcount,
+                                                     GLsizei stride);
+angle::CallCapture CaptureMultiDrawElementsIndirectEXT(const State &glState,
+                                                       bool isCallValid,
+                                                       PrimitiveMode modePacked,
+                                                       DrawElementsType typePacked,
+                                                       const void *indirect,
+                                                       GLsizei drawcount,
+                                                       GLsizei stride);
+
+// GL_EXT_multisampled_render_to_texture
+angle::CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState,
+                                                             bool isCallValid,
+                                                             GLenum target,
+                                                             GLenum attachment,
+                                                             TextureTarget textargetPacked,
+                                                             TextureID texturePacked,
+                                                             GLint level,
+                                                             GLsizei samples);
+angle::CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState,
+                                                            bool isCallValid,
+                                                            GLenum target,
+                                                            GLsizei samples,
+                                                            GLenum internalformat,
+                                                            GLsizei width,
+                                                            GLsizei height);
+
+// GL_EXT_multisampled_render_to_texture2
+
+// GL_EXT_occlusion_query_boolean
+
+// GL_EXT_primitive_bounding_box
+angle::CallCapture CapturePrimitiveBoundingBoxEXT(const State &glState,
+                                                  bool isCallValid,
+                                                  GLfloat minX,
+                                                  GLfloat minY,
+                                                  GLfloat minZ,
+                                                  GLfloat minW,
+                                                  GLfloat maxX,
+                                                  GLfloat maxY,
+                                                  GLfloat maxZ,
+                                                  GLfloat maxW);
+
+// GL_EXT_protected_textures
+
+// GL_EXT_pvrtc_sRGB
+
+// GL_EXT_read_format_bgra
+
+// GL_EXT_robustness
+angle::CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum returnValue);
+angle::CallCapture CaptureGetnUniformfvEXT(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLsizei bufSize,
+                                           GLfloat *params);
+angle::CallCapture CaptureGetnUniformivEXT(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           UniformLocation locationPacked,
+                                           GLsizei bufSize,
+                                           GLint *params);
+angle::CallCapture CaptureReadnPixelsEXT(const State &glState,
+                                         bool isCallValid,
+                                         GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         void *data);
+
+// GL_EXT_sRGB
+
+// GL_EXT_sRGB_write_control
+
+// GL_EXT_semaphore
+angle::CallCapture CaptureDeleteSemaphoresEXT(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              const SemaphoreID *semaphoresPacked);
+angle::CallCapture CaptureGenSemaphoresEXT(const State &glState,
+                                           bool isCallValid,
+                                           GLsizei n,
+                                           SemaphoreID *semaphoresPacked);
+angle::CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState,
+                                                        bool isCallValid,
+                                                        SemaphoreID semaphorePacked,
+                                                        GLenum pname,
+                                                        GLuint64 *params);
+angle::CallCapture CaptureIsSemaphoreEXT(const State &glState,
+                                         bool isCallValid,
+                                         SemaphoreID semaphorePacked,
+                                         GLboolean returnValue);
+angle::CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState,
+                                                     bool isCallValid,
+                                                     SemaphoreID semaphorePacked,
+                                                     GLenum pname,
+                                                     const GLuint64 *params);
+angle::CallCapture CaptureSignalSemaphoreEXT(const State &glState,
+                                             bool isCallValid,
+                                             SemaphoreID semaphorePacked,
+                                             GLuint numBufferBarriers,
+                                             const BufferID *buffersPacked,
+                                             GLuint numTextureBarriers,
+                                             const TextureID *texturesPacked,
+                                             const GLenum *dstLayouts);
+angle::CallCapture CaptureWaitSemaphoreEXT(const State &glState,
+                                           bool isCallValid,
+                                           SemaphoreID semaphorePacked,
+                                           GLuint numBufferBarriers,
+                                           const BufferID *buffersPacked,
+                                           GLuint numTextureBarriers,
+                                           const TextureID *texturesPacked,
+                                           const GLenum *srcLayouts);
+
+// GL_EXT_semaphore_fd
+angle::CallCapture CaptureImportSemaphoreFdEXT(const State &glState,
+                                               bool isCallValid,
+                                               SemaphoreID semaphorePacked,
+                                               HandleType handleTypePacked,
+                                               GLint fd);
+
+// GL_EXT_separate_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
+
+// GL_EXT_shader_framebuffer_fetch_non_coherent
+angle::CallCapture CaptureFramebufferFetchBarrierEXT(const State &glState, bool isCallValid);
+
+// GL_EXT_shader_io_blocks
+
+// GL_EXT_shader_non_constant_global_initializers
+
+// GL_EXT_shader_texture_lod
+
+// GL_EXT_shadow_samplers
+
+// GL_EXT_tessellation_shader
+angle::CallCapture CapturePatchParameteriEXT(const State &glState,
+                                             bool isCallValid,
+                                             GLenum pname,
+                                             GLint value);
+
+// GL_EXT_texture_border_clamp
+angle::CallCapture CaptureGetSamplerParameterIivEXT(const State &glState,
+                                                    bool isCallValid,
+                                                    SamplerID samplerPacked,
+                                                    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_format_sRGB_override
+
+// GL_EXT_texture_norm16
+
+// GL_EXT_texture_rg
+
+// GL_EXT_texture_sRGB_R8
+
+// GL_EXT_texture_sRGB_RG8
+
+// GL_EXT_texture_sRGB_decode
+
+// 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_EXT_texture_type_2_10_10_10_REV
+
+// GL_EXT_unpack_subimage
+
+// GL_IMG_texture_compression_pvrtc
+
+// GL_IMG_texture_compression_pvrtc2
+
+// GL_KHR_blend_equation_advanced
+angle::CallCapture CaptureBlendBarrierKHR(const State &glState, bool isCallValid);
+
+// GL_KHR_debug
+angle::CallCapture CaptureDebugMessageCallbackKHR(const State &glState,
+                                                  bool isCallValid,
+                                                  GLDEBUGPROCKHR callback,
+                                                  const void *userParam);
+angle::CallCapture CaptureDebugMessageControlKHR(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum source,
+                                                 GLenum type,
+                                                 GLenum severity,
+                                                 GLsizei count,
+                                                 const GLuint *ids,
+                                                 GLboolean enabled);
+angle::CallCapture CaptureDebugMessageInsertKHR(const State &glState,
+                                                bool isCallValid,
+                                                GLenum source,
+                                                GLenum type,
+                                                GLuint id,
+                                                GLenum severity,
+                                                GLsizei length,
+                                                const GLchar *buf);
+angle::CallCapture CaptureGetDebugMessageLogKHR(const State &glState,
+                                                bool isCallValid,
+                                                GLuint count,
+                                                GLsizei bufSize,
+                                                GLenum *sources,
+                                                GLenum *types,
+                                                GLuint *ids,
+                                                GLenum *severities,
+                                                GLsizei *lengths,
+                                                GLchar *messageLog,
+                                                GLuint returnValue);
+angle::CallCapture CaptureGetObjectLabelKHR(const State &glState,
+                                            bool isCallValid,
+                                            GLenum identifier,
+                                            GLuint name,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLchar *label);
+angle::CallCapture CaptureGetObjectPtrLabelKHR(const State &glState,
+                                               bool isCallValid,
+                                               const void *ptr,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLchar *label);
+angle::CallCapture CaptureGetPointervKHR(const State &glState,
+                                         bool isCallValid,
+                                         GLenum pname,
+                                         void **params);
+angle::CallCapture CaptureObjectLabelKHR(const State &glState,
+                                         bool isCallValid,
+                                         GLenum identifier,
+                                         GLuint name,
+                                         GLsizei length,
+                                         const GLchar *label);
+angle::CallCapture CaptureObjectPtrLabelKHR(const State &glState,
+                                            bool isCallValid,
+                                            const void *ptr,
+                                            GLsizei length,
+                                            const GLchar *label);
+angle::CallCapture CapturePopDebugGroupKHR(const State &glState, bool isCallValid);
+angle::CallCapture CapturePushDebugGroupKHR(const State &glState,
+                                            bool isCallValid,
+                                            GLenum source,
+                                            GLuint id,
+                                            GLsizei length,
+                                            const GLchar *message);
+
+// GL_KHR_no_error
+
+// GL_KHR_parallel_shader_compile
+angle::CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState,
+                                                      bool isCallValid,
+                                                      GLuint count);
+
+// GL_KHR_robust_buffer_access_behavior
+
+// GL_KHR_texture_compression_astc_hdr
+
+// GL_KHR_texture_compression_astc_ldr
+
+// GL_KHR_texture_compression_astc_sliced_3d
+
+// GL_MESA_framebuffer_flip_y
+angle::CallCapture CaptureFramebufferParameteriMESA(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum target,
+                                                    GLenum pname,
+                                                    GLint param);
+angle::CallCapture CaptureGetFramebufferParameterivMESA(const State &glState,
+                                                        bool isCallValid,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLint *params);
+
+// GL_NV_fence
+angle::CallCapture CaptureDeleteFencesNV(const State &glState,
+                                         bool isCallValid,
+                                         GLsizei n,
+                                         const FenceNVID *fencesPacked);
+angle::CallCapture CaptureFinishFenceNV(const State &glState,
+                                        bool isCallValid,
+                                        FenceNVID fencePacked);
+angle::CallCapture CaptureGenFencesNV(const State &glState,
+                                      bool isCallValid,
+                                      GLsizei n,
+                                      FenceNVID *fencesPacked);
+angle::CallCapture CaptureGetFenceivNV(const State &glState,
+                                       bool isCallValid,
+                                       FenceNVID fencePacked,
+                                       GLenum pname,
+                                       GLint *params);
+angle::CallCapture CaptureIsFenceNV(const State &glState,
+                                    bool isCallValid,
+                                    FenceNVID fencePacked,
+                                    GLboolean returnValue);
+angle::CallCapture CaptureSetFenceNV(const State &glState,
+                                     bool isCallValid,
+                                     FenceNVID fencePacked,
+                                     GLenum condition);
+angle::CallCapture CaptureTestFenceNV(const State &glState,
+                                      bool isCallValid,
+                                      FenceNVID fencePacked,
+                                      GLboolean returnValue);
+
+// GL_NV_framebuffer_blit
+angle::CallCapture CaptureBlitFramebufferNV(const State &glState,
+                                            bool isCallValid,
+                                            GLint srcX0,
+                                            GLint srcY0,
+                                            GLint srcX1,
+                                            GLint srcY1,
+                                            GLint dstX0,
+                                            GLint dstY0,
+                                            GLint dstX1,
+                                            GLint dstY1,
+                                            GLbitfield mask,
+                                            GLenum filter);
+
+// GL_NV_pixel_buffer_object
+
+// GL_NV_read_depth
+
+// GL_NV_read_depth_stencil
+
+// GL_NV_read_stencil
+
+// GL_NV_robustness_video_memory_purge
+
+// GL_NV_shader_noperspective_interpolation
+
+// GL_OES_EGL_image
+angle::CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState,
+                                                               bool isCallValid,
+                                                               GLenum target,
+                                                               GLeglImageOES image);
+angle::CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureType targetPacked,
+                                                     GLeglImageOES image);
+
+// GL_OES_EGL_image_external
+
+// GL_OES_EGL_image_external_essl3
+
+// GL_OES_compressed_ETC1_RGB8_texture
+
+// GL_OES_compressed_paletted_texture
+
+// GL_OES_copy_image
+angle::CallCapture CaptureCopyImageSubDataOES(const State &glState,
+                                              bool isCallValid,
+                                              GLuint srcName,
+                                              GLenum srcTarget,
+                                              GLint srcLevel,
+                                              GLint srcX,
+                                              GLint srcY,
+                                              GLint srcZ,
+                                              GLuint dstName,
+                                              GLenum dstTarget,
+                                              GLint dstLevel,
+                                              GLint dstX,
+                                              GLint dstY,
+                                              GLint dstZ,
+                                              GLsizei srcWidth,
+                                              GLsizei srcHeight,
+                                              GLsizei srcDepth);
+
+// GL_OES_depth24
+
+// GL_OES_depth32
+
+// GL_OES_depth_texture
+
+// GL_OES_draw_buffers_indexed
+angle::CallCapture CaptureBlendEquationSeparateiOES(const State &glState,
+                                                    bool isCallValid,
+                                                    GLuint buf,
+                                                    GLenum modeRGB,
+                                                    GLenum modeAlpha);
+angle::CallCapture CaptureBlendEquationiOES(const State &glState,
+                                            bool isCallValid,
+                                            GLuint buf,
+                                            GLenum mode);
+angle::CallCapture CaptureBlendFuncSeparateiOES(const State &glState,
+                                                bool isCallValid,
+                                                GLuint buf,
+                                                GLenum srcRGB,
+                                                GLenum dstRGB,
+                                                GLenum srcAlpha,
+                                                GLenum dstAlpha);
+angle::CallCapture CaptureBlendFunciOES(const State &glState,
+                                        bool isCallValid,
+                                        GLuint buf,
+                                        GLenum src,
+                                        GLenum dst);
+angle::CallCapture CaptureColorMaskiOES(const State &glState,
+                                        bool isCallValid,
+                                        GLuint index,
+                                        GLboolean r,
+                                        GLboolean g,
+                                        GLboolean b,
+                                        GLboolean a);
+angle::CallCapture CaptureDisableiOES(const State &glState,
+                                      bool isCallValid,
+                                      GLenum target,
+                                      GLuint index);
+angle::CallCapture CaptureEnableiOES(const State &glState,
+                                     bool isCallValid,
+                                     GLenum target,
+                                     GLuint index);
+angle::CallCapture CaptureIsEnablediOES(const State &glState,
+                                        bool isCallValid,
+                                        GLenum target,
+                                        GLuint index,
+                                        GLboolean returnValue);
+
+// GL_OES_draw_elements_base_vertex
+angle::CallCapture CaptureDrawElementsBaseVertexOES(const State &glState,
+                                                    bool isCallValid,
+                                                    PrimitiveMode modePacked,
+                                                    GLsizei count,
+                                                    DrawElementsType typePacked,
+                                                    const void *indices,
+                                                    GLint basevertex);
+angle::CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState,
+                                                             bool isCallValid,
+                                                             PrimitiveMode modePacked,
+                                                             GLsizei count,
+                                                             DrawElementsType typePacked,
+                                                             const void *indices,
+                                                             GLsizei instancecount,
+                                                             GLint basevertex);
+angle::CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState,
+                                                         bool isCallValid,
+                                                         PrimitiveMode modePacked,
+                                                         GLuint start,
+                                                         GLuint end,
+                                                         GLsizei count,
+                                                         DrawElementsType typePacked,
+                                                         const void *indices,
+                                                         GLint basevertex);
+
+// GL_OES_draw_texture
+angle::CallCapture CaptureDrawTexfOES(const State &glState,
+                                      bool isCallValid,
+                                      GLfloat x,
+                                      GLfloat y,
+                                      GLfloat z,
+                                      GLfloat width,
+                                      GLfloat height);
+angle::CallCapture CaptureDrawTexfvOES(const State &glState,
+                                       bool isCallValid,
+                                       const GLfloat *coords);
+angle::CallCapture CaptureDrawTexiOES(const State &glState,
+                                      bool isCallValid,
+                                      GLint x,
+                                      GLint y,
+                                      GLint z,
+                                      GLint width,
+                                      GLint height);
+angle::CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords);
+angle::CallCapture CaptureDrawTexsOES(const State &glState,
+                                      bool isCallValid,
+                                      GLshort x,
+                                      GLshort y,
+                                      GLshort z,
+                                      GLshort width,
+                                      GLshort height);
+angle::CallCapture CaptureDrawTexsvOES(const State &glState,
+                                       bool isCallValid,
+                                       const GLshort *coords);
+angle::CallCapture CaptureDrawTexxOES(const State &glState,
+                                      bool isCallValid,
+                                      GLfixed x,
+                                      GLfixed y,
+                                      GLfixed z,
+                                      GLfixed width,
+                                      GLfixed height);
+angle::CallCapture CaptureDrawTexxvOES(const State &glState,
+                                       bool isCallValid,
+                                       const GLfixed *coords);
+
+// GL_OES_element_index_uint
+
+// GL_OES_fbo_render_mipmap
+
+// GL_OES_framebuffer_object
+angle::CallCapture CaptureBindFramebufferOES(const State &glState,
+                                             bool isCallValid,
+                                             GLenum target,
+                                             FramebufferID framebufferPacked);
+angle::CallCapture CaptureBindRenderbufferOES(const State &glState,
+                                              bool isCallValid,
+                                              GLenum target,
+                                              RenderbufferID renderbufferPacked);
+angle::CallCapture CaptureCheckFramebufferStatusOES(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum target,
+                                                    GLenum returnValue);
+angle::CallCapture CaptureDeleteFramebuffersOES(const State &glState,
+                                                bool isCallValid,
+                                                GLsizei n,
+                                                const FramebufferID *framebuffersPacked);
+angle::CallCapture CaptureDeleteRenderbuffersOES(const State &glState,
+                                                 bool isCallValid,
+                                                 GLsizei n,
+                                                 const RenderbufferID *renderbuffersPacked);
+angle::CallCapture CaptureFramebufferRenderbufferOES(const State &glState,
+                                                     bool isCallValid,
+                                                     GLenum target,
+                                                     GLenum attachment,
+                                                     GLenum renderbuffertarget,
+                                                     RenderbufferID renderbufferPacked);
+angle::CallCapture CaptureFramebufferTexture2DOES(const State &glState,
+                                                  bool isCallValid,
+                                                  GLenum target,
+                                                  GLenum attachment,
+                                                  TextureTarget textargetPacked,
+                                                  TextureID texturePacked,
+                                                  GLint level);
+angle::CallCapture CaptureGenFramebuffersOES(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             FramebufferID *framebuffersPacked);
+angle::CallCapture CaptureGenRenderbuffersOES(const State &glState,
+                                              bool isCallValid,
+                                              GLsizei n,
+                                              RenderbufferID *renderbuffersPacked);
+angle::CallCapture CaptureGenerateMipmapOES(const State &glState,
+                                            bool isCallValid,
+                                            TextureType targetPacked);
+angle::CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState,
+                                                                 bool isCallValid,
+                                                                 GLenum target,
+                                                                 GLenum attachment,
+                                                                 GLenum pname,
+                                                                 GLint *params);
+angle::CallCapture CaptureGetRenderbufferParameterivOES(const State &glState,
+                                                        bool isCallValid,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLint *params);
+angle::CallCapture CaptureIsFramebufferOES(const State &glState,
+                                           bool isCallValid,
+                                           FramebufferID framebufferPacked,
+                                           GLboolean returnValue);
+angle::CallCapture CaptureIsRenderbufferOES(const State &glState,
+                                            bool isCallValid,
+                                            RenderbufferID renderbufferPacked,
+                                            GLboolean returnValue);
+angle::CallCapture CaptureRenderbufferStorageOES(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum target,
+                                                 GLenum internalformat,
+                                                 GLsizei width,
+                                                 GLsizei height);
+
+// GL_OES_geometry_shader
+angle::CallCapture CaptureFramebufferTextureOES(const State &glState,
+                                                bool isCallValid,
+                                                GLenum target,
+                                                GLenum attachment,
+                                                TextureID texturePacked,
+                                                GLint level);
+
+// GL_OES_get_program_binary
+angle::CallCapture CaptureGetProgramBinaryOES(const State &glState,
+                                              bool isCallValid,
+                                              ShaderProgramID programPacked,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLenum *binaryFormat,
+                                              void *binary);
+angle::CallCapture CaptureProgramBinaryOES(const State &glState,
+                                           bool isCallValid,
+                                           ShaderProgramID programPacked,
+                                           GLenum binaryFormat,
+                                           const void *binary,
+                                           GLint length);
+
+// GL_OES_mapbuffer
+angle::CallCapture CaptureGetBufferPointervOES(const State &glState,
+                                               bool isCallValid,
+                                               BufferBinding targetPacked,
+                                               GLenum pname,
+                                               void **params);
+angle::CallCapture CaptureMapBufferOES(const State &glState,
+                                       bool isCallValid,
+                                       BufferBinding targetPacked,
+                                       GLenum access,
+                                       void *returnValue);
+angle::CallCapture CaptureUnmapBufferOES(const State &glState,
+                                         bool isCallValid,
+                                         BufferBinding targetPacked,
+                                         GLboolean returnValue);
+
+// GL_OES_matrix_palette
+angle::CallCapture CaptureCurrentPaletteMatrixOES(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint matrixpaletteindex);
+angle::CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid);
+angle::CallCapture CaptureMatrixIndexPointerOES(const State &glState,
+                                                bool isCallValid,
+                                                GLint size,
+                                                GLenum type,
+                                                GLsizei stride,
+                                                const void *pointer);
+angle::CallCapture CaptureWeightPointerOES(const State &glState,
+                                           bool isCallValid,
+                                           GLint size,
+                                           GLenum type,
+                                           GLsizei stride,
+                                           const void *pointer);
+
+// GL_OES_packed_depth_stencil
+
+// GL_OES_point_size_array
+angle::CallCapture CapturePointSizePointerOES(const State &glState,
+                                              bool isCallValid,
+                                              VertexAttribType typePacked,
+                                              GLsizei stride,
+                                              const void *pointer);
+
+// GL_OES_point_sprite
+
+// GL_OES_primitive_bounding_box
+angle::CallCapture CapturePrimitiveBoundingBoxOES(const State &glState,
+                                                  bool isCallValid,
+                                                  GLfloat minX,
+                                                  GLfloat minY,
+                                                  GLfloat minZ,
+                                                  GLfloat minW,
+                                                  GLfloat maxX,
+                                                  GLfloat maxY,
+                                                  GLfloat maxZ,
+                                                  GLfloat maxW);
+
+// GL_OES_query_matrix
+angle::CallCapture CaptureQueryMatrixxOES(const State &glState,
+                                          bool isCallValid,
+                                          GLfixed *mantissa,
+                                          GLint *exponent,
+                                          GLbitfield returnValue);
+
+// GL_OES_rgb8_rgba8
+
+// GL_OES_sample_shading
+angle::CallCapture CaptureMinSampleShadingOES(const State &glState,
+                                              bool isCallValid,
+                                              GLfloat value);
+
+// GL_OES_sample_variables
+
+// GL_OES_shader_image_atomic
+
+// GL_OES_shader_io_blocks
+
+// GL_OES_shader_multisample_interpolation
+
+// GL_OES_standard_derivatives
+
+// GL_OES_surfaceless_context
+
+// GL_OES_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_compression_astc
+
+// GL_OES_texture_cube_map
+angle::CallCapture CaptureGetTexGenfvOES(const State &glState,
+                                         bool isCallValid,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         GLfloat *params);
+angle::CallCapture CaptureGetTexGenivOES(const State &glState,
+                                         bool isCallValid,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         GLint *params);
+angle::CallCapture CaptureGetTexGenxvOES(const State &glState,
+                                         bool isCallValid,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         GLfixed *params);
+angle::CallCapture CaptureTexGenfOES(const State &glState,
+                                     bool isCallValid,
+                                     GLenum coord,
+                                     GLenum pname,
+                                     GLfloat param);
+angle::CallCapture CaptureTexGenfvOES(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      const GLfloat *params);
+angle::CallCapture CaptureTexGeniOES(const State &glState,
+                                     bool isCallValid,
+                                     GLenum coord,
+                                     GLenum pname,
+                                     GLint param);
+angle::CallCapture CaptureTexGenivOES(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      const GLint *params);
+angle::CallCapture CaptureTexGenxOES(const State &glState,
+                                     bool isCallValid,
+                                     GLenum coord,
+                                     GLenum pname,
+                                     GLfixed param);
+angle::CallCapture CaptureTexGenxvOES(const State &glState,
+                                      bool isCallValid,
+                                      GLenum coord,
+                                      GLenum pname,
+                                      const GLfixed *params);
+
+// GL_OES_texture_cube_map_array
+
+// GL_OES_texture_float
+
+// GL_OES_texture_float_linear
+
+// GL_OES_texture_half_float
+
+// GL_OES_texture_half_float_linear
+
+// GL_OES_texture_npot
+
+// GL_OES_texture_stencil8
+
+// GL_OES_texture_storage_multisample_2d_array
+angle::CallCapture CaptureTexStorage3DMultisampleOES(const State &glState,
+                                                     bool isCallValid,
+                                                     TextureType targetPacked,
+                                                     GLsizei samples,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLsizei depth,
+                                                     GLboolean fixedsamplelocations);
+
+// GL_OES_vertex_array_object
+angle::CallCapture CaptureBindVertexArrayOES(const State &glState,
+                                             bool isCallValid,
+                                             VertexArrayID arrayPacked);
+angle::CallCapture CaptureDeleteVertexArraysOES(const State &glState,
+                                                bool isCallValid,
+                                                GLsizei n,
+                                                const VertexArrayID *arraysPacked);
+angle::CallCapture CaptureGenVertexArraysOES(const State &glState,
+                                             bool isCallValid,
+                                             GLsizei n,
+                                             VertexArrayID *arraysPacked);
+angle::CallCapture CaptureIsVertexArrayOES(const State &glState,
+                                           bool isCallValid,
+                                           VertexArrayID arrayPacked,
+                                           GLboolean returnValue);
+
+// GL_OES_vertex_half_float
+
+// GL_OES_vertex_type_10_10_10_2
+
+// GL_OVR_multiview
+angle::CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState,
+                                                         bool isCallValid,
+                                                         GLenum target,
+                                                         GLenum attachment,
+                                                         TextureID texturePacked,
+                                                         GLint level,
+                                                         GLint baseViewIndex,
+                                                         GLsizei numViews);
+
+// GL_OVR_multiview2
+
+// GL_QCOM_shading_rate
+angle::CallCapture CaptureShadingRateQCOM(const State &glState, bool isCallValid, GLenum rate);
+
+// Parameter Captures
+
+void CaptureDeletePerfMonitorsAMD_monitors(const State &glState,
+                                           bool isCallValid,
+                                           GLsizei n,
+                                           GLuint *monitors,
+                                           angle::ParamCapture *paramCapture);
+void CaptureGenPerfMonitorsAMD_monitors(const State &glState,
+                                        bool isCallValid,
+                                        GLsizei n,
+                                        GLuint *monitors,
+                                        angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorCounterDataAMD_data(const State &glState,
+                                              bool isCallValid,
+                                              GLuint monitor,
+                                              GLenum pname,
+                                              GLsizei dataSize,
+                                              GLuint *data,
+                                              GLint *bytesWritten,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorCounterDataAMD_bytesWritten(const State &glState,
+                                                      bool isCallValid,
+                                                      GLuint monitor,
+                                                      GLenum pname,
+                                                      GLsizei dataSize,
+                                                      GLuint *data,
+                                                      GLint *bytesWritten,
+                                                      angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorCounterInfoAMD_data(const State &glState,
+                                              bool isCallValid,
+                                              GLuint group,
+                                              GLuint counter,
+                                              GLenum pname,
+                                              void *data,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorCounterStringAMD_length(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint group,
+                                                  GLuint counter,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLchar *counterString,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorCounterStringAMD_counterString(const State &glState,
+                                                         bool isCallValid,
+                                                         GLuint group,
+                                                         GLuint counter,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLchar *counterString,
+                                                         angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorCountersAMD_numCounters(const State &glState,
+                                                  bool isCallValid,
+                                                  GLuint group,
+                                                  GLint *numCounters,
+                                                  GLint *maxActiveCounters,
+                                                  GLsizei counterSize,
+                                                  GLuint *counters,
+                                                  angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorCountersAMD_maxActiveCounters(const State &glState,
+                                                        bool isCallValid,
+                                                        GLuint group,
+                                                        GLint *numCounters,
+                                                        GLint *maxActiveCounters,
+                                                        GLsizei counterSize,
+                                                        GLuint *counters,
+                                                        angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorCountersAMD_counters(const State &glState,
+                                               bool isCallValid,
+                                               GLuint group,
+                                               GLint *numCounters,
+                                               GLint *maxActiveCounters,
+                                               GLsizei counterSize,
+                                               GLuint *counters,
+                                               angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorGroupStringAMD_length(const State &glState,
+                                                bool isCallValid,
+                                                GLuint group,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLchar *groupString,
+                                                angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorGroupStringAMD_groupString(const State &glState,
+                                                     bool isCallValid,
+                                                     GLuint group,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLchar *groupString,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorGroupsAMD_numGroups(const State &glState,
+                                              bool isCallValid,
+                                              GLint *numGroups,
+                                              GLsizei groupsSize,
+                                              GLuint *groups,
+                                              angle::ParamCapture *paramCapture);
+void CaptureGetPerfMonitorGroupsAMD_groups(const State &glState,
+                                           bool isCallValid,
+                                           GLint *numGroups,
+                                           GLsizei groupsSize,
+                                           GLuint *groups,
+                                           angle::ParamCapture *paramCapture);
+void CaptureSelectPerfMonitorCountersAMD_counterList(const State &glState,
+                                                     bool isCallValid,
+                                                     GLuint monitor,
+                                                     GLboolean enable,
+                                                     GLuint group,
+                                                     GLint numCounters,
+                                                     GLuint *counterList,
+                                                     angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    GLsizei count,
+    DrawElementsType typePacked,
+    const GLvoid *indices,
+    GLsizei instanceCount,
+    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 CaptureGetCompressedTexImageANGLE_pixels(const State &glState,
+                                              bool isCallValid,
+                                              TextureTarget targetPacked,
+                                              GLint level,
+                                              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 CaptureTexStorageMemFlags2DANGLE_imageCreateInfoPNext(const State &glState,
+                                                           bool isCallValid,
+                                                           TextureType targetPacked,
+                                                           GLsizei levels,
+                                                           GLenum internalFormat,
+                                                           GLsizei width,
+                                                           GLsizei height,
+                                                           MemoryObjectID memoryPacked,
+                                                           GLuint64 offset,
+                                                           GLbitfield createFlags,
+                                                           GLbitfield usageFlags,
+                                                           const void *imageCreateInfoPNext,
+                                                           angle::ParamCapture *paramCapture);
+void CaptureTexStorageMemFlags2DMultisampleANGLE_imageCreateInfoPNext(
+    const State &glState,
+    bool isCallValid,
+    TextureType targetPacked,
+    GLsizei samples,
+    GLenum internalFormat,
+    GLsizei width,
+    GLsizei height,
+    GLboolean fixedSampleLocations,
+    MemoryObjectID memoryPacked,
+    GLuint64 offset,
+    GLbitfield createFlags,
+    GLbitfield usageFlags,
+    const void *imageCreateInfoPNext,
+    angle::ParamCapture *paramCapture);
+void CaptureTexStorageMemFlags3DANGLE_imageCreateInfoPNext(const State &glState,
+                                                           bool isCallValid,
+                                                           TextureType targetPacked,
+                                                           GLsizei levels,
+                                                           GLenum internalFormat,
+                                                           GLsizei width,
+                                                           GLsizei height,
+                                                           GLsizei depth,
+                                                           MemoryObjectID memoryPacked,
+                                                           GLuint64 offset,
+                                                           GLbitfield createFlags,
+                                                           GLbitfield usageFlags,
+                                                           const void *imageCreateInfoPNext,
+                                                           angle::ParamCapture *paramCapture);
+void CaptureTexStorageMemFlags3DMultisampleANGLE_imageCreateInfoPNext(
+    const State &glState,
+    bool isCallValid,
+    TextureType targetPacked,
+    GLsizei samples,
+    GLenum internalFormat,
+    GLsizei width,
+    GLsizei height,
+    GLsizei depth,
+    GLboolean fixedSampleLocations,
+    MemoryObjectID memoryPacked,
+    GLuint64 offset,
+    GLbitfield createFlags,
+    GLbitfield usageFlags,
+    const void *imageCreateInfoPNext,
+    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 CaptureBeginPixelLocalStorageANGLE_loadops(const State &glState,
+                                                bool isCallValid,
+                                                GLsizei planes,
+                                                const GLenum *loadops,
+                                                const void *cleardata,
+                                                angle::ParamCapture *paramCapture);
+void CaptureBeginPixelLocalStorageANGLE_cleardata(const State &glState,
+                                                  bool isCallValid,
+                                                  GLsizei planes,
+                                                  const GLenum *loadops,
+                                                  const void *cleardata,
+                                                  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 CaptureAcquireTexturesANGLE_texturesPacked(const State &glState,
+                                                bool isCallValid,
+                                                GLuint numTextures,
+                                                const TextureID *texturesPacked,
+                                                const GLenum *layouts,
+                                                angle::ParamCapture *paramCapture);
+void CaptureAcquireTexturesANGLE_layouts(const State &glState,
+                                         bool isCallValid,
+                                         GLuint numTextures,
+                                         const TextureID *texturesPacked,
+                                         const GLenum *layouts,
+                                         angle::ParamCapture *paramCapture);
+void CaptureReleaseTexturesANGLE_texturesPacked(const State &glState,
+                                                bool isCallValid,
+                                                GLuint numTextures,
+                                                const TextureID *texturesPacked,
+                                                GLenum *layouts,
+                                                angle::ParamCapture *paramCapture);
+void CaptureReleaseTexturesANGLE_layouts(const State &glState,
+                                         bool isCallValid,
+                                         GLuint numTextures,
+                                         const TextureID *texturesPacked,
+                                         GLenum *layouts,
+                                         angle::ParamCapture *paramCapture);
+void CaptureBindUniformLocationCHROMIUM_name(const State &glState,
+                                             bool isCallValid,
+                                             ShaderProgramID programPacked,
+                                             UniformLocation locationPacked,
+                                             const GLchar *name,
+                                             angle::ParamCapture *paramCapture);
+void CaptureEGLImageTargetTexStorageEXT_attrib_list(const State &glState,
+                                                    bool isCallValid,
+                                                    GLenum target,
+                                                    GLeglImageOES image,
+                                                    const GLint *attrib_list,
+                                                    angle::ParamCapture *paramCapture);
+void CaptureEGLImageTargetTextureStorageEXT_attrib_list(const State &glState,
+                                                        bool isCallValid,
+                                                        GLuint texture,
+                                                        GLeglImageOES image,
+                                                        const GLint *attrib_list,
+                                                        angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedBaseInstanceEXT_indices(const State &glState,
+                                                         bool isCallValid,
+                                                         PrimitiveMode modePacked,
+                                                         GLsizei count,
+                                                         DrawElementsType typePacked,
+                                                         const void *indices,
+                                                         GLsizei instancecount,
+                                                         GLuint baseinstance,
+                                                         angle::ParamCapture *paramCapture);
+void CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT_indices(
+    const State &glState,
+    bool isCallValid,
+    PrimitiveMode modePacked,
+    GLsizei count,
+    DrawElementsType typePacked,
+    const void *indices,
+    GLsizei instancecount,
+    GLint basevertex,
+    GLuint baseinstance,
+    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 drawcount,
+                                                 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 drawcount,
+                                                   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 drawcount,
+                                                      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 CaptureMultiDrawArraysIndirectEXT_indirect(const State &glState,
+                                                bool isCallValid,
+                                                PrimitiveMode modePacked,
+                                                const void *indirect,
+                                                GLsizei drawcount,
+                                                GLsizei stride,
+                                                angle::ParamCapture *paramCapture);
+void CaptureMultiDrawElementsIndirectEXT_indirect(const State &glState,
+                                                  bool isCallValid,
+                                                  PrimitiveMode modePacked,
+                                                  DrawElementsType typePacked,
+                                                  const void *indirect,
+                                                  GLsizei drawcount,
+                                                  GLsizei stride,
+                                                  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 CaptureGetFramebufferParameterivMESA_params(const State &glState,
+                                                 bool isCallValid,
+                                                 GLenum target,
+                                                 GLenum pname,
+                                                 GLint *params,
+                                                 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..9c76c2fc15
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_autogen.h
@@ -0,0 +1,3257 @@
+// 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
+{
+    TAHardwareBufferConstPointer,
+    TAlphaTestFunc,
+    TBufferBinding,
+    TBufferID,
+    TBufferIDConstPointer,
+    TBufferIDPointer,
+    TBufferUsage,
+    TClientVertexArrayType,
+    TCompositorTiming,
+    TCullFaceMode,
+    TDrawElementsType,
+    TEGLAttrib,
+    TEGLAttribKHR,
+    TEGLBoolean,
+    TEGLClientBuffer,
+    TEGLConfig,
+    TEGLContext,
+    TEGLDEBUGPROCKHR,
+    TEGLDeviceEXT,
+    TEGLDisplay,
+    TEGLFrameTokenANGLE,
+    TEGLGetBlobFuncANDROID,
+    TEGLImage,
+    TEGLLabelKHR,
+    TEGLNativeDisplayType,
+    TEGLNativePixmapType,
+    TEGLNativeWindowType,
+    TEGLObjectKHR,
+    TEGLSetBlobFuncANDROID,
+    TEGLStreamKHR,
+    TEGLSurface,
+    TEGLSync,
+    TEGLTime,
+    TEGLTimeKHR,
+    TEGLenum,
+    TEGLint,
+    TEGLnsecsANDROID,
+    TEGLuint64KHR,
+    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,
+    TObjectType,
+    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,
+    TTimestamp,
+    TTransformFeedbackID,
+    TTransformFeedbackIDConstPointer,
+    TTransformFeedbackIDPointer,
+    TUniformBlockIndex,
+    TUniformLocation,
+    TVertexArrayID,
+    TVertexArrayIDConstPointer,
+    TVertexArrayIDPointer,
+    TVertexAttribType,
+    TcharConstPointer,
+    TvoidConstPointer,
+    TvoidConstPointerPointer,
+    TvoidPointer,
+    TvoidPointerPointer,
+};
+
+constexpr uint32_t kParamTypeCount = 154;
+
+union ParamValue
+{
+    const AHardwareBuffer *AHardwareBufferConstPointerVal;
+    gl::AlphaTestFunc AlphaTestFuncVal;
+    gl::BufferBinding BufferBindingVal;
+    gl::BufferID BufferIDVal;
+    const gl::BufferID *BufferIDConstPointerVal;
+    gl::BufferID *BufferIDPointerVal;
+    gl::BufferUsage BufferUsageVal;
+    gl::ClientVertexArrayType ClientVertexArrayTypeVal;
+    egl::CompositorTiming CompositorTimingVal;
+    gl::CullFaceMode CullFaceModeVal;
+    gl::DrawElementsType DrawElementsTypeVal;
+    EGLAttrib EGLAttribVal;
+    EGLAttribKHR EGLAttribKHRVal;
+    EGLBoolean EGLBooleanVal;
+    EGLClientBuffer EGLClientBufferVal;
+    EGLConfig EGLConfigVal;
+    EGLContext EGLContextVal;
+    EGLDEBUGPROCKHR EGLDEBUGPROCKHRVal;
+    EGLDeviceEXT EGLDeviceEXTVal;
+    EGLDisplay EGLDisplayVal;
+    EGLFrameTokenANGLE EGLFrameTokenANGLEVal;
+    EGLGetBlobFuncANDROID EGLGetBlobFuncANDROIDVal;
+    EGLImage EGLImageVal;
+    EGLLabelKHR EGLLabelKHRVal;
+    EGLNativeDisplayType EGLNativeDisplayTypeVal;
+    EGLNativePixmapType EGLNativePixmapTypeVal;
+    EGLNativeWindowType EGLNativeWindowTypeVal;
+    EGLObjectKHR EGLObjectKHRVal;
+    EGLSetBlobFuncANDROID EGLSetBlobFuncANDROIDVal;
+    EGLStreamKHR EGLStreamKHRVal;
+    EGLSurface EGLSurfaceVal;
+    EGLSync EGLSyncVal;
+    EGLTime EGLTimeVal;
+    EGLTimeKHR EGLTimeKHRVal;
+    EGLenum EGLenumVal;
+    EGLint EGLintVal;
+    EGLnsecsANDROID EGLnsecsANDROIDVal;
+    EGLuint64KHR EGLuint64KHRVal;
+    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;
+    egl::ObjectType ObjectTypeVal;
+    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;
+    egl::Timestamp TimestampVal;
+    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 char *charConstPointerVal;
+    const void *voidConstPointerVal;
+    const void *const *voidConstPointerPointerVal;
+    void *voidPointerVal;
+    void **voidPointerPointerVal;
+};
+
+template <ParamType PType, typename T>
+T GetParamVal(const ParamValue &value);
+
+template <>
+inline const AHardwareBuffer *GetParamVal<ParamType::TAHardwareBufferConstPointer,
+                                          const AHardwareBuffer *>(const ParamValue &value)
+{
+    return value.AHardwareBufferConstPointerVal;
+}
+
+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 egl::CompositorTiming GetParamVal<ParamType::TCompositorTiming, egl::CompositorTiming>(
+    const ParamValue &value)
+{
+    return value.CompositorTimingVal;
+}
+
+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 EGLAttrib GetParamVal<ParamType::TEGLAttrib, EGLAttrib>(const ParamValue &value)
+{
+    return value.EGLAttribVal;
+}
+
+template <>
+inline EGLAttribKHR GetParamVal<ParamType::TEGLAttribKHR, EGLAttribKHR>(const ParamValue &value)
+{
+    return value.EGLAttribKHRVal;
+}
+
+template <>
+inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value)
+{
+    return value.EGLBooleanVal;
+}
+
+template <>
+inline EGLClientBuffer GetParamVal<ParamType::TEGLClientBuffer, EGLClientBuffer>(
+    const ParamValue &value)
+{
+    return value.EGLClientBufferVal;
+}
+
+template <>
+inline EGLConfig GetParamVal<ParamType::TEGLConfig, EGLConfig>(const ParamValue &value)
+{
+    return value.EGLConfigVal;
+}
+
+template <>
+inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value)
+{
+    return value.EGLContextVal;
+}
+
+template <>
+inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>(
+    const ParamValue &value)
+{
+    return value.EGLDEBUGPROCKHRVal;
+}
+
+template <>
+inline EGLDeviceEXT GetParamVal<ParamType::TEGLDeviceEXT, EGLDeviceEXT>(const ParamValue &value)
+{
+    return value.EGLDeviceEXTVal;
+}
+
+template <>
+inline EGLDisplay GetParamVal<ParamType::TEGLDisplay, EGLDisplay>(const ParamValue &value)
+{
+    return value.EGLDisplayVal;
+}
+
+template <>
+inline EGLFrameTokenANGLE GetParamVal<ParamType::TEGLFrameTokenANGLE, EGLFrameTokenANGLE>(
+    const ParamValue &value)
+{
+    return value.EGLFrameTokenANGLEVal;
+}
+
+template <>
+inline EGLGetBlobFuncANDROID GetParamVal<ParamType::TEGLGetBlobFuncANDROID, EGLGetBlobFuncANDROID>(
+    const ParamValue &value)
+{
+    return value.EGLGetBlobFuncANDROIDVal;
+}
+
+template <>
+inline EGLImage GetParamVal<ParamType::TEGLImage, EGLImage>(const ParamValue &value)
+{
+    return value.EGLImageVal;
+}
+
+template <>
+inline EGLLabelKHR GetParamVal<ParamType::TEGLLabelKHR, EGLLabelKHR>(const ParamValue &value)
+{
+    return value.EGLLabelKHRVal;
+}
+
+template <>
+inline EGLNativeDisplayType GetParamVal<ParamType::TEGLNativeDisplayType, EGLNativeDisplayType>(
+    const ParamValue &value)
+{
+    return value.EGLNativeDisplayTypeVal;
+}
+
+template <>
+inline EGLNativePixmapType GetParamVal<ParamType::TEGLNativePixmapType, EGLNativePixmapType>(
+    const ParamValue &value)
+{
+    return value.EGLNativePixmapTypeVal;
+}
+
+template <>
+inline EGLNativeWindowType GetParamVal<ParamType::TEGLNativeWindowType, EGLNativeWindowType>(
+    const ParamValue &value)
+{
+    return value.EGLNativeWindowTypeVal;
+}
+
+template <>
+inline EGLObjectKHR GetParamVal<ParamType::TEGLObjectKHR, EGLObjectKHR>(const ParamValue &value)
+{
+    return value.EGLObjectKHRVal;
+}
+
+template <>
+inline EGLSetBlobFuncANDROID GetParamVal<ParamType::TEGLSetBlobFuncANDROID, EGLSetBlobFuncANDROID>(
+    const ParamValue &value)
+{
+    return value.EGLSetBlobFuncANDROIDVal;
+}
+
+template <>
+inline EGLStreamKHR GetParamVal<ParamType::TEGLStreamKHR, EGLStreamKHR>(const ParamValue &value)
+{
+    return value.EGLStreamKHRVal;
+}
+
+template <>
+inline EGLSurface GetParamVal<ParamType::TEGLSurface, EGLSurface>(const ParamValue &value)
+{
+    return value.EGLSurfaceVal;
+}
+
+template <>
+inline EGLSync GetParamVal<ParamType::TEGLSync, EGLSync>(const ParamValue &value)
+{
+    return value.EGLSyncVal;
+}
+
+template <>
+inline EGLTime GetParamVal<ParamType::TEGLTime, EGLTime>(const ParamValue &value)
+{
+    return value.EGLTimeVal;
+}
+
+template <>
+inline EGLTimeKHR GetParamVal<ParamType::TEGLTimeKHR, EGLTimeKHR>(const ParamValue &value)
+{
+    return value.EGLTimeKHRVal;
+}
+
+template <>
+inline EGLenum GetParamVal<ParamType::TEGLenum, EGLenum>(const ParamValue &value)
+{
+    return value.EGLenumVal;
+}
+
+template <>
+inline EGLint GetParamVal<ParamType::TEGLint, EGLint>(const ParamValue &value)
+{
+    return value.EGLintVal;
+}
+
+template <>
+inline EGLnsecsANDROID GetParamVal<ParamType::TEGLnsecsANDROID, EGLnsecsANDROID>(
+    const ParamValue &value)
+{
+    return value.EGLnsecsANDROIDVal;
+}
+
+template <>
+inline EGLuint64KHR GetParamVal<ParamType::TEGLuint64KHR, EGLuint64KHR>(const ParamValue &value)
+{
+    return value.EGLuint64KHRVal;
+}
+
+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 egl::ObjectType GetParamVal<ParamType::TObjectType, egl::ObjectType>(const ParamValue &value)
+{
+    return value.ObjectTypeVal;
+}
+
+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 egl::Timestamp GetParamVal<ParamType::TTimestamp, egl::Timestamp>(const ParamValue &value)
+{
+    return value.TimestampVal;
+}
+
+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 char *GetParamVal<ParamType::TcharConstPointer, const char *>(const ParamValue &value)
+{
+    return value.charConstPointerVal;
+}
+
+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::TAHardwareBufferConstPointer:
+            return GetParamVal<ParamType::TAHardwareBufferConstPointer, T>(value);
+        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::TCompositorTiming:
+            return GetParamVal<ParamType::TCompositorTiming, T>(value);
+        case ParamType::TCullFaceMode:
+            return GetParamVal<ParamType::TCullFaceMode, T>(value);
+        case ParamType::TDrawElementsType:
+            return GetParamVal<ParamType::TDrawElementsType, T>(value);
+        case ParamType::TEGLAttrib:
+            return GetParamVal<ParamType::TEGLAttrib, T>(value);
+        case ParamType::TEGLAttribKHR:
+            return GetParamVal<ParamType::TEGLAttribKHR, T>(value);
+        case ParamType::TEGLBoolean:
+            return GetParamVal<ParamType::TEGLBoolean, T>(value);
+        case ParamType::TEGLClientBuffer:
+            return GetParamVal<ParamType::TEGLClientBuffer, T>(value);
+        case ParamType::TEGLConfig:
+            return GetParamVal<ParamType::TEGLConfig, T>(value);
+        case ParamType::TEGLContext:
+            return GetParamVal<ParamType::TEGLContext, T>(value);
+        case ParamType::TEGLDEBUGPROCKHR:
+            return GetParamVal<ParamType::TEGLDEBUGPROCKHR, T>(value);
+        case ParamType::TEGLDeviceEXT:
+            return GetParamVal<ParamType::TEGLDeviceEXT, T>(value);
+        case ParamType::TEGLDisplay:
+            return GetParamVal<ParamType::TEGLDisplay, T>(value);
+        case ParamType::TEGLFrameTokenANGLE:
+            return GetParamVal<ParamType::TEGLFrameTokenANGLE, T>(value);
+        case ParamType::TEGLGetBlobFuncANDROID:
+            return GetParamVal<ParamType::TEGLGetBlobFuncANDROID, T>(value);
+        case ParamType::TEGLImage:
+            return GetParamVal<ParamType::TEGLImage, T>(value);
+        case ParamType::TEGLLabelKHR:
+            return GetParamVal<ParamType::TEGLLabelKHR, T>(value);
+        case ParamType::TEGLNativeDisplayType:
+            return GetParamVal<ParamType::TEGLNativeDisplayType, T>(value);
+        case ParamType::TEGLNativePixmapType:
+            return GetParamVal<ParamType::TEGLNativePixmapType, T>(value);
+        case ParamType::TEGLNativeWindowType:
+            return GetParamVal<ParamType::TEGLNativeWindowType, T>(value);
+        case ParamType::TEGLObjectKHR:
+            return GetParamVal<ParamType::TEGLObjectKHR, T>(value);
+        case ParamType::TEGLSetBlobFuncANDROID:
+            return GetParamVal<ParamType::TEGLSetBlobFuncANDROID, T>(value);
+        case ParamType::TEGLStreamKHR:
+            return GetParamVal<ParamType::TEGLStreamKHR, T>(value);
+        case ParamType::TEGLSurface:
+            return GetParamVal<ParamType::TEGLSurface, T>(value);
+        case ParamType::TEGLSync:
+            return GetParamVal<ParamType::TEGLSync, T>(value);
+        case ParamType::TEGLTime:
+            return GetParamVal<ParamType::TEGLTime, T>(value);
+        case ParamType::TEGLTimeKHR:
+            return GetParamVal<ParamType::TEGLTimeKHR, T>(value);
+        case ParamType::TEGLenum:
+            return GetParamVal<ParamType::TEGLenum, T>(value);
+        case ParamType::TEGLint:
+            return GetParamVal<ParamType::TEGLint, T>(value);
+        case ParamType::TEGLnsecsANDROID:
+            return GetParamVal<ParamType::TEGLnsecsANDROID, T>(value);
+        case ParamType::TEGLuint64KHR:
+            return GetParamVal<ParamType::TEGLuint64KHR, 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::TObjectType:
+            return GetParamVal<ParamType::TObjectType, 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::TTimestamp:
+            return GetParamVal<ParamType::TTimestamp, 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::TcharConstPointer:
+            return GetParamVal<ParamType::TcharConstPointer, 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);
+    }
+    UNREACHABLE();
+    return T();
+}
+
+template <ParamType PType, typename T>
+void SetParamVal(T valueIn, ParamValue *valueOut);
+
+template <>
+inline void SetParamVal<ParamType::TAHardwareBufferConstPointer>(const AHardwareBuffer *valueIn,
+                                                                 ParamValue *valueOut)
+{
+    valueOut->AHardwareBufferConstPointerVal = valueIn;
+}
+
+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::TCompositorTiming>(egl::CompositorTiming valueIn,
+                                                      ParamValue *valueOut)
+{
+    valueOut->CompositorTimingVal = 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::TEGLAttrib>(EGLAttrib valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLAttribVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLAttribKHR>(EGLAttribKHR valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLAttribKHRVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLBooleanVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLClientBuffer>(EGLClientBuffer valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLClientBufferVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLConfig>(EGLConfig valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLConfigVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLContext>(EGLContext valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLContextVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLDEBUGPROCKHR>(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLDEBUGPROCKHRVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLDeviceEXT>(EGLDeviceEXT valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLDeviceEXTVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLDisplay>(EGLDisplay valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLDisplayVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLFrameTokenANGLE>(EGLFrameTokenANGLE valueIn,
+                                                        ParamValue *valueOut)
+{
+    valueOut->EGLFrameTokenANGLEVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(EGLGetBlobFuncANDROID valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->EGLGetBlobFuncANDROIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLImage>(EGLImage valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLImageVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLLabelKHR>(EGLLabelKHR valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLLabelKHRVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLNativeDisplayType>(EGLNativeDisplayType valueIn,
+                                                          ParamValue *valueOut)
+{
+    valueOut->EGLNativeDisplayTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLNativePixmapType>(EGLNativePixmapType valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->EGLNativePixmapTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLNativeWindowType>(EGLNativeWindowType valueIn,
+                                                         ParamValue *valueOut)
+{
+    valueOut->EGLNativeWindowTypeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLObjectKHR>(EGLObjectKHR valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLObjectKHRVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(EGLSetBlobFuncANDROID valueIn,
+                                                           ParamValue *valueOut)
+{
+    valueOut->EGLSetBlobFuncANDROIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLStreamKHR>(EGLStreamKHR valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLStreamKHRVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLSurface>(EGLSurface valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLSurfaceVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLSync>(EGLSync valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLSyncVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLTime>(EGLTime valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLTimeVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLTimeKHR>(EGLTimeKHR valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLTimeKHRVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLenum>(EGLenum valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLenumVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLint>(EGLint valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLintVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLnsecsANDROID>(EGLnsecsANDROID valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLnsecsANDROIDVal = valueIn;
+}
+
+template <>
+inline void SetParamVal<ParamType::TEGLuint64KHR>(EGLuint64KHR valueIn, ParamValue *valueOut)
+{
+    valueOut->EGLuint64KHRVal = 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::TObjectType>(egl::ObjectType valueIn, ParamValue *valueOut)
+{
+    valueOut->ObjectTypeVal = 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::TTimestamp>(egl::Timestamp valueIn, ParamValue *valueOut)
+{
+    valueOut->TimestampVal = 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::TcharConstPointer>(const char *valueIn, ParamValue *valueOut)
+{
+    valueOut->charConstPointerVal = 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::TAHardwareBufferConstPointer:
+            SetParamVal<ParamType::TAHardwareBufferConstPointer>(valueIn, valueOut);
+            break;
+        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::TCompositorTiming:
+            SetParamVal<ParamType::TCompositorTiming>(valueIn, valueOut);
+            break;
+        case ParamType::TCullFaceMode:
+            SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut);
+            break;
+        case ParamType::TDrawElementsType:
+            SetParamVal<ParamType::TDrawElementsType>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLAttrib:
+            SetParamVal<ParamType::TEGLAttrib>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLAttribKHR:
+            SetParamVal<ParamType::TEGLAttribKHR>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLBoolean:
+            SetParamVal<ParamType::TEGLBoolean>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLClientBuffer:
+            SetParamVal<ParamType::TEGLClientBuffer>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLConfig:
+            SetParamVal<ParamType::TEGLConfig>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLContext:
+            SetParamVal<ParamType::TEGLContext>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLDEBUGPROCKHR:
+            SetParamVal<ParamType::TEGLDEBUGPROCKHR>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLDeviceEXT:
+            SetParamVal<ParamType::TEGLDeviceEXT>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLDisplay:
+            SetParamVal<ParamType::TEGLDisplay>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLFrameTokenANGLE:
+            SetParamVal<ParamType::TEGLFrameTokenANGLE>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLGetBlobFuncANDROID:
+            SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLImage:
+            SetParamVal<ParamType::TEGLImage>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLLabelKHR:
+            SetParamVal<ParamType::TEGLLabelKHR>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLNativeDisplayType:
+            SetParamVal<ParamType::TEGLNativeDisplayType>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLNativePixmapType:
+            SetParamVal<ParamType::TEGLNativePixmapType>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLNativeWindowType:
+            SetParamVal<ParamType::TEGLNativeWindowType>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLObjectKHR:
+            SetParamVal<ParamType::TEGLObjectKHR>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLSetBlobFuncANDROID:
+            SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLStreamKHR:
+            SetParamVal<ParamType::TEGLStreamKHR>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLSurface:
+            SetParamVal<ParamType::TEGLSurface>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLSync:
+            SetParamVal<ParamType::TEGLSync>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLTime:
+            SetParamVal<ParamType::TEGLTime>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLTimeKHR:
+            SetParamVal<ParamType::TEGLTimeKHR>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLenum:
+            SetParamVal<ParamType::TEGLenum>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLint:
+            SetParamVal<ParamType::TEGLint>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLnsecsANDROID:
+            SetParamVal<ParamType::TEGLnsecsANDROID>(valueIn, valueOut);
+            break;
+        case ParamType::TEGLuint64KHR:
+            SetParamVal<ParamType::TEGLuint64KHR>(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::TObjectType:
+            SetParamVal<ParamType::TObjectType>(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::TTimestamp:
+            SetParamVal<ParamType::TTimestamp>(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::TcharConstPointer:
+            SetParamVal<ParamType::TcharConstPointer>(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);
+
+template <typename ResourceType>
+struct GetResourceIDTypeFromType;
+
+template <>
+struct GetResourceIDTypeFromType<gl::BufferID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::Buffer;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::FenceNVID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::FenceNV;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::FramebufferID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::Framebuffer;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::MemoryObjectID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::MemoryObject;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::ProgramPipelineID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::ProgramPipeline;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::QueryID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::Query;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::RenderbufferID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::Renderbuffer;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::SamplerID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::Sampler;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::SemaphoreID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::Semaphore;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::ShaderProgramID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::ShaderProgram;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::TextureID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::Texture;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::TransformFeedbackID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::TransformFeedback;
+};
+
+template <>
+struct GetResourceIDTypeFromType<gl::VertexArrayID>
+{
+    static constexpr ResourceIDType IDType = ResourceIDType::VertexArray;
+};
+
+}  // 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..1fac416138
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils.h
@@ -0,0 +1,32 @@
+//
+// 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(GLESEnum enumGroup, unsigned int value);
+const char *GLenumToString(BigGLEnum enumGroup, unsigned int value);
+std::string GLbitfieldToString(GLESEnum enumGroup, unsigned int value);
+std::string GLbitfieldToString(BigGLEnum enumGroup, unsigned int value);
+void OutputGLenumString(std::ostream &out, GLESEnum enumGroup, unsigned int value);
+void OutputGLenumString(std::ostream &out, BigGLEnum enumGroup, unsigned int value);
+void OutputGLbitfieldString(std::ostream &out, GLESEnum enumGroup, unsigned int value);
+const char *GLinternalFormatToString(unsigned int format);
+
+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..6d0fe3da3e
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils_autogen.h
@@ -0,0 +1,419 @@
+// 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 GLESEnum
+{
+    AccumOp,
+    AllEnums,
+    AlphaFunction,
+    AtomicCounterBufferPName,
+    AttribMask,
+    AttributeType,
+    BindTransformFeedbackTarget,
+    BinormalPointerTypeEXT,
+    BlendEquationModeEXT,
+    BlendingFactor,
+    BlitFramebufferFilter,
+    Boolean,
+    Buffer,
+    BufferAccessARB,
+    BufferPNameARB,
+    BufferPointerNameARB,
+    BufferStorageMask,
+    BufferStorageTarget,
+    BufferTargetARB,
+    BufferUsageARB,
+    ClampColorModeARB,
+    ClearBufferMask,
+    ClipPlaneName,
+    ColorBuffer,
+    ColorMaterialParameter,
+    ColorPointerType,
+    CombinerBiasNV,
+    CombinerComponentUsageNV,
+    CombinerPortionNV,
+    CombinerScaleNV,
+    ContainerType,
+    ContextFlagMask,
+    CopyBufferSubDataTarget,
+    CopyImageSubDataTarget,
+    DebugSeverity,
+    DebugSource,
+    DebugType,
+    DepthFunction,
+    DepthStencilTextureMode,
+    DrawBufferMode,
+    DrawElementsType,
+    ElementPointerTypeATI,
+    EnableCap,
+    ErrorCode,
+    ExternalHandleType,
+    FenceConditionNV,
+    FenceParameterNameNV,
+    FogCoordinatePointerType,
+    FogMode,
+    FogPName,
+    FogParameter,
+    FogPointerTypeEXT,
+    FogPointerTypeIBM,
+    FragmentLightParameterSGIX,
+    FragmentShaderDestMaskATI,
+    FragmentShaderDestModMaskATI,
+    FragmentShaderGenericSourceATI,
+    FragmentShaderTextureSourceATI,
+    FragmentShaderValueRepATI,
+    FramebufferAttachment,
+    FramebufferAttachmentParameterName,
+    FramebufferParameterName,
+    FramebufferStatus,
+    FramebufferTarget,
+    FrontFaceDirection,
+    GetFramebufferParameter,
+    GetMultisamplePNameNV,
+    GetPName,
+    GetPointervPName,
+    GetTextureParameter,
+    GraphicsResetStatus,
+    HintMode,
+    HintTarget,
+    IndexFunctionEXT,
+    IndexPointerType,
+    InternalFormat,
+    InternalFormatPName,
+    InvalidateFramebufferAttachment,
+    LightEnvModeSGIX,
+    LightModelParameter,
+    LightName,
+    LightParameter,
+    ListNameType,
+    LogicOp,
+    MapBufferAccessMask,
+    MapTypeNV,
+    MaterialParameter,
+    MatrixIndexPointerTypeARB,
+    MatrixMode,
+    MemoryBarrierMask,
+    MemoryObjectParameterName,
+    NormalPointerType,
+    ObjectIdentifier,
+    PatchParameterName,
+    PathColor,
+    PathColorFormat,
+    PathFillMode,
+    PathFontStyle,
+    PathGenMode,
+    PathTransformType,
+    PipelineParameterName,
+    PixelCopyType,
+    PixelFormat,
+    PixelStoreParameter,
+    PixelTexGenModeSGIX,
+    PixelTransferParameter,
+    PixelType,
+    PointParameterNameARB,
+    PrecisionType,
+    PrimitiveType,
+    ProgramInterface,
+    ProgramInterfacePName,
+    ProgramParameterPName,
+    ProgramPropertyARB,
+    ProgramResourceProperty,
+    QueryCounterTarget,
+    QueryObjectParameterName,
+    QueryParameterName,
+    QueryTarget,
+    ReadBufferMode,
+    RenderbufferParameterName,
+    RenderbufferTarget,
+    ReplacementCodeTypeSUN,
+    SamplerParameterF,
+    SamplerParameterI,
+    ScalarType,
+    SecondaryColorPointerTypeIBM,
+    SemaphoreParameterName,
+    ShaderBinaryFormat,
+    ShaderParameterName,
+    ShaderType,
+    ShadingModel,
+    ShadingRateQCOM,
+    SizedInternalFormat,
+    StencilFunction,
+    StencilOp,
+    StringName,
+    SubroutineParameterName,
+    SyncBehaviorFlags,
+    SyncCondition,
+    SyncObjectMask,
+    SyncParameterName,
+    SyncStatus,
+    TangentPointerTypeEXT,
+    TexCoordPointerType,
+    TextureCompareMode,
+    TextureCoordName,
+    TextureEnvMode,
+    TextureEnvParameter,
+    TextureEnvTarget,
+    TextureGenParameter,
+    TextureLayout,
+    TextureMagFilter,
+    TextureMinFilter,
+    TextureParameterName,
+    TextureSwizzle,
+    TextureTarget,
+    TextureUnit,
+    TextureWrapMode,
+    TransformFeedbackBufferMode,
+    TransformFeedbackPName,
+    TriangleFace,
+    UniformBlockPName,
+    UniformPName,
+    UniformType,
+    UseProgramStageMask,
+    VertexArrayPName,
+    VertexAttribEnum,
+    VertexAttribIType,
+    VertexAttribPointerPropertyARB,
+    VertexAttribPointerType,
+    VertexAttribPropertyARB,
+    VertexAttribType,
+    VertexBufferObjectUsage,
+    VertexPointerType,
+    VertexProvokingMode,
+    VertexShaderTextureUnitParameter,
+    VertexShaderWriteMaskEXT,
+    VertexWeightPointerTypeEXT,
+    WeightPointerTypeARB
+};
+
+enum class BigGLEnum
+{
+    AccumOp,
+    AllEnums,
+    AlphaFunction,
+    AtomicCounterBufferPName,
+    AttribMask,
+    AttributeType,
+    BindTransformFeedbackTarget,
+    BinormalPointerTypeEXT,
+    BlendEquationModeEXT,
+    BlendingFactor,
+    BlitFramebufferFilter,
+    Boolean,
+    Buffer,
+    BufferAccessARB,
+    BufferPNameARB,
+    BufferPointerNameARB,
+    BufferStorageMask,
+    BufferStorageTarget,
+    BufferTargetARB,
+    BufferUsageARB,
+    ClampColorModeARB,
+    ClampColorTargetARB,
+    ClearBufferMask,
+    ClientAttribMask,
+    ClipControlDepth,
+    ClipControlOrigin,
+    ClipPlaneName,
+    ColorBuffer,
+    ColorMaterialParameter,
+    ColorPointerType,
+    ColorTableTarget,
+    ColorTableTargetSGI,
+    CombinerBiasNV,
+    CombinerComponentUsageNV,
+    CombinerPortionNV,
+    CombinerScaleNV,
+    ConditionalRenderMode,
+    ContainerType,
+    ContextFlagMask,
+    ContextProfileMask,
+    ConvolutionTarget,
+    ConvolutionTargetEXT,
+    CopyBufferSubDataTarget,
+    CopyImageSubDataTarget,
+    DebugSeverity,
+    DebugSource,
+    DebugType,
+    DepthFunction,
+    DepthStencilTextureMode,
+    DrawBufferMode,
+    DrawElementsType,
+    ElementPointerTypeATI,
+    EnableCap,
+    ErrorCode,
+    ExternalHandleType,
+    FeedBackToken,
+    FeedbackType,
+    FenceConditionNV,
+    FenceParameterNameNV,
+    FogCoordSrc,
+    FogCoordinatePointerType,
+    FogMode,
+    FogPName,
+    FogParameter,
+    FogPointerTypeEXT,
+    FogPointerTypeIBM,
+    FragmentLightParameterSGIX,
+    FragmentShaderDestMaskATI,
+    FragmentShaderDestModMaskATI,
+    FragmentShaderGenericSourceATI,
+    FragmentShaderTextureSourceATI,
+    FragmentShaderValueRepATI,
+    FramebufferAttachment,
+    FramebufferAttachmentParameterName,
+    FramebufferParameterName,
+    FramebufferStatus,
+    FramebufferTarget,
+    FrontFaceDirection,
+    GetFramebufferParameter,
+    GetMapQuery,
+    GetMultisamplePNameNV,
+    GetPName,
+    GetPointervPName,
+    GetTextureParameter,
+    GraphicsResetStatus,
+    HintMode,
+    HintTarget,
+    HistogramTarget,
+    HistogramTargetEXT,
+    IndexFunctionEXT,
+    IndexMaterialParameterEXT,
+    IndexPointerType,
+    InterleavedArrayFormat,
+    InternalFormat,
+    InternalFormatPName,
+    InvalidateFramebufferAttachment,
+    LightEnvModeSGIX,
+    LightModelColorControl,
+    LightModelParameter,
+    LightName,
+    LightParameter,
+    LightTextureModeEXT,
+    ListMode,
+    ListNameType,
+    LogicOp,
+    MapBufferAccessMask,
+    MapQuery,
+    MapTarget,
+    MapTypeNV,
+    MaterialParameter,
+    MatrixIndexPointerTypeARB,
+    MatrixMode,
+    MemoryBarrierMask,
+    MemoryObjectParameterName,
+    MeshMode1,
+    MeshMode2,
+    MinmaxTarget,
+    MinmaxTargetEXT,
+    NormalPointerType,
+    ObjectIdentifier,
+    PatchParameterName,
+    PathColor,
+    PathColorFormat,
+    PathFillMode,
+    PathFontStyle,
+    PathGenMode,
+    PathTransformType,
+    PipelineParameterName,
+    PixelCopyType,
+    PixelFormat,
+    PixelMap,
+    PixelStoreParameter,
+    PixelTexGenModeSGIX,
+    PixelTransferParameter,
+    PixelType,
+    PointParameterNameARB,
+    PolygonMode,
+    PrecisionType,
+    PrimitiveType,
+    ProgramInterface,
+    ProgramInterfacePName,
+    ProgramParameterPName,
+    ProgramPropertyARB,
+    ProgramResourceProperty,
+    ProgramStagePName,
+    QueryCounterTarget,
+    QueryObjectParameterName,
+    QueryParameterName,
+    QueryTarget,
+    ReadBufferMode,
+    RenderbufferParameterName,
+    RenderbufferTarget,
+    RenderingMode,
+    ReplacementCodeTypeSUN,
+    SamplerParameterF,
+    SamplerParameterI,
+    ScalarType,
+    SecondaryColorPointerTypeIBM,
+    SemaphoreParameterName,
+    SeparableTarget,
+    SeparableTargetEXT,
+    ShaderBinaryFormat,
+    ShaderParameterName,
+    ShaderType,
+    ShadingModel,
+    SizedInternalFormat,
+    StencilFunction,
+    StencilOp,
+    StringName,
+    SubroutineParameterName,
+    SyncBehaviorFlags,
+    SyncCondition,
+    SyncObjectMask,
+    SyncParameterName,
+    SyncStatus,
+    TangentPointerTypeEXT,
+    TexCoordPointerType,
+    TextureCompareMode,
+    TextureCoordName,
+    TextureEnvMode,
+    TextureEnvParameter,
+    TextureEnvTarget,
+    TextureGenMode,
+    TextureGenParameter,
+    TextureLayout,
+    TextureMagFilter,
+    TextureMinFilter,
+    TextureParameterName,
+    TextureSwizzle,
+    TextureTarget,
+    TextureUnit,
+    TextureWrapMode,
+    TransformFeedbackBufferMode,
+    TransformFeedbackPName,
+    TriangleFace,
+    UniformBlockPName,
+    UniformPName,
+    UniformType,
+    UseProgramStageMask,
+    VertexArrayPName,
+    VertexAttribEnum,
+    VertexAttribIType,
+    VertexAttribLType,
+    VertexAttribPointerPropertyARB,
+    VertexAttribPointerType,
+    VertexAttribPropertyARB,
+    VertexAttribType,
+    VertexBufferObjectUsage,
+    VertexPointerType,
+    VertexProvokingMode,
+    VertexShaderTextureUnitParameter,
+    VertexShaderWriteMaskEXT,
+    VertexWeightPointerTypeEXT,
+    WeightPointerTypeARB
+};
+}  // namespace gl
+
+#endif  // LIBANGLE_GL_ENUM_UTILS_AUTOGEN_H_