chromium/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file is auto-generated from
// gpu/command_buffer/build_gles2_cmd_buffer.py
// It's formatted by clang-format using chromium coding style:
//    clang-format -i -style=chromium filename
// DO NOT EDIT!

// This file is included by gles2_trace_implementation.cc
#ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_TRACE_IMPLEMENTATION_IMPL_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_CLIENT_GLES2_TRACE_IMPLEMENTATION_IMPL_AUTOGEN_H_

void GLES2TraceImplementation::ActiveTexture(GLenum texture) { … }

void GLES2TraceImplementation::AttachShader(GLuint program, GLuint shader) { … }

void GLES2TraceImplementation::BindAttribLocation(GLuint program,
                                                  GLuint index,
                                                  const char* name) { … }

void GLES2TraceImplementation::BindBuffer(GLenum target, GLuint buffer) { … }

void GLES2TraceImplementation::BindBufferBase(GLenum target,
                                              GLuint index,
                                              GLuint buffer) { … }

void GLES2TraceImplementation::BindBufferRange(GLenum target,
                                               GLuint index,
                                               GLuint buffer,
                                               GLintptr offset,
                                               GLsizeiptr size) { … }

void GLES2TraceImplementation::BindFramebuffer(GLenum target,
                                               GLuint framebuffer) { … }

void GLES2TraceImplementation::BindRenderbuffer(GLenum target,
                                                GLuint renderbuffer) { … }

void GLES2TraceImplementation::BindSampler(GLuint unit, GLuint sampler) { … }

void GLES2TraceImplementation::BindTexture(GLenum target, GLuint texture) { … }

void GLES2TraceImplementation::BindTransformFeedback(GLenum target,
                                                     GLuint transformfeedback) { … }

void GLES2TraceImplementation::BlendColor(GLclampf red,
                                          GLclampf green,
                                          GLclampf blue,
                                          GLclampf alpha) { … }

void GLES2TraceImplementation::BlendEquation(GLenum mode) { … }

void GLES2TraceImplementation::BlendEquationSeparate(GLenum modeRGB,
                                                     GLenum modeAlpha) { … }

void GLES2TraceImplementation::BlendFunc(GLenum sfactor, GLenum dfactor) { … }

void GLES2TraceImplementation::BlendFuncSeparate(GLenum srcRGB,
                                                 GLenum dstRGB,
                                                 GLenum srcAlpha,
                                                 GLenum dstAlpha) { … }

void GLES2TraceImplementation::BufferData(GLenum target,
                                          GLsizeiptr size,
                                          const void* data,
                                          GLenum usage) { … }

void GLES2TraceImplementation::BufferSubData(GLenum target,
                                             GLintptr offset,
                                             GLsizeiptr size,
                                             const void* data) { … }

GLenum GLES2TraceImplementation::CheckFramebufferStatus(GLenum target) { … }

void GLES2TraceImplementation::Clear(GLbitfield mask) { … }

void GLES2TraceImplementation::ClearBufferfi(GLenum buffer,
                                             GLint drawbuffers,
                                             GLfloat depth,
                                             GLint stencil) { … }

void GLES2TraceImplementation::ClearBufferfv(GLenum buffer,
                                             GLint drawbuffers,
                                             const GLfloat* value) { … }

void GLES2TraceImplementation::ClearBufferiv(GLenum buffer,
                                             GLint drawbuffers,
                                             const GLint* value) { … }

void GLES2TraceImplementation::ClearBufferuiv(GLenum buffer,
                                              GLint drawbuffers,
                                              const GLuint* value) { … }

void GLES2TraceImplementation::ClearColor(GLclampf red,
                                          GLclampf green,
                                          GLclampf blue,
                                          GLclampf alpha) { … }

void GLES2TraceImplementation::ClearDepthf(GLclampf depth) { … }

void GLES2TraceImplementation::ClearStencil(GLint s) { … }

GLenum GLES2TraceImplementation::ClientWaitSync(GLsync sync,
                                                GLbitfield flags,
                                                GLuint64 timeout) { … }

void GLES2TraceImplementation::ColorMask(GLboolean red,
                                         GLboolean green,
                                         GLboolean blue,
                                         GLboolean alpha) { … }

void GLES2TraceImplementation::CompileShader(GLuint shader) { … }

void GLES2TraceImplementation::CompressedTexImage2D(GLenum target,
                                                    GLint level,
                                                    GLenum internalformat,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLint border,
                                                    GLsizei imageSize,
                                                    const void* data) { … }

void GLES2TraceImplementation::CompressedTexSubImage2D(GLenum target,
                                                       GLint level,
                                                       GLint xoffset,
                                                       GLint yoffset,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLenum format,
                                                       GLsizei imageSize,
                                                       const void* data) { … }

void GLES2TraceImplementation::CompressedTexImage3D(GLenum target,
                                                    GLint level,
                                                    GLenum internalformat,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLsizei depth,
                                                    GLint border,
                                                    GLsizei imageSize,
                                                    const void* data) { … }

void GLES2TraceImplementation::CompressedTexSubImage3D(GLenum target,
                                                       GLint level,
                                                       GLint xoffset,
                                                       GLint yoffset,
                                                       GLint zoffset,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLsizei depth,
                                                       GLenum format,
                                                       GLsizei imageSize,
                                                       const void* data) { … }

void GLES2TraceImplementation::CopyBufferSubData(GLenum readtarget,
                                                 GLenum writetarget,
                                                 GLintptr readoffset,
                                                 GLintptr writeoffset,
                                                 GLsizeiptr size) { … }

void GLES2TraceImplementation::CopyTexImage2D(GLenum target,
                                              GLint level,
                                              GLenum internalformat,
                                              GLint x,
                                              GLint y,
                                              GLsizei width,
                                              GLsizei height,
                                              GLint border) { … }

void GLES2TraceImplementation::CopyTexSubImage2D(GLenum target,
                                                 GLint level,
                                                 GLint xoffset,
                                                 GLint yoffset,
                                                 GLint x,
                                                 GLint y,
                                                 GLsizei width,
                                                 GLsizei height) { … }

void GLES2TraceImplementation::CopyTexSubImage3D(GLenum target,
                                                 GLint level,
                                                 GLint xoffset,
                                                 GLint yoffset,
                                                 GLint zoffset,
                                                 GLint x,
                                                 GLint y,
                                                 GLsizei width,
                                                 GLsizei height) { … }

GLuint GLES2TraceImplementation::CreateProgram() { … }

GLuint GLES2TraceImplementation::CreateShader(GLenum type) { … }

void GLES2TraceImplementation::CullFace(GLenum mode) { … }

void GLES2TraceImplementation::DeleteBuffers(GLsizei n, const GLuint* buffers) { … }

void GLES2TraceImplementation::DeleteFramebuffers(GLsizei n,
                                                  const GLuint* framebuffers) { … }

void GLES2TraceImplementation::DeleteProgram(GLuint program) { … }

void GLES2TraceImplementation::DeleteRenderbuffers(
    GLsizei n,
    const GLuint* renderbuffers) { … }

void GLES2TraceImplementation::DeleteSamplers(GLsizei n,
                                              const GLuint* samplers) { … }

void GLES2TraceImplementation::DeleteSync(GLsync sync) { … }

void GLES2TraceImplementation::DeleteShader(GLuint shader) { … }

void GLES2TraceImplementation::DeleteTextures(GLsizei n,
                                              const GLuint* textures) { … }

void GLES2TraceImplementation::DeleteTransformFeedbacks(GLsizei n,
                                                        const GLuint* ids) { … }

void GLES2TraceImplementation::DepthFunc(GLenum func) { … }

void GLES2TraceImplementation::DepthMask(GLboolean flag) { … }

void GLES2TraceImplementation::DepthRangef(GLclampf zNear, GLclampf zFar) { … }

void GLES2TraceImplementation::DetachShader(GLuint program, GLuint shader) { … }

void GLES2TraceImplementation::Disable(GLenum cap) { … }

void GLES2TraceImplementation::DisableVertexAttribArray(GLuint index) { … }

void GLES2TraceImplementation::DrawArrays(GLenum mode,
                                          GLint first,
                                          GLsizei count) { … }

void GLES2TraceImplementation::DrawElements(GLenum mode,
                                            GLsizei count,
                                            GLenum type,
                                            const void* indices) { … }

void GLES2TraceImplementation::DrawRangeElements(GLenum mode,
                                                 GLuint start,
                                                 GLuint end,
                                                 GLsizei count,
                                                 GLenum type,
                                                 const void* indices) { … }

void GLES2TraceImplementation::Enable(GLenum cap) { … }

void GLES2TraceImplementation::EnableVertexAttribArray(GLuint index) { … }

GLsync GLES2TraceImplementation::FenceSync(GLenum condition, GLbitfield flags) { … }

void GLES2TraceImplementation::Finish() { … }

void GLES2TraceImplementation::Flush() { … }

void GLES2TraceImplementation::FramebufferRenderbuffer(
    GLenum target,
    GLenum attachment,
    GLenum renderbuffertarget,
    GLuint renderbuffer) { … }

void GLES2TraceImplementation::FramebufferTexture2D(GLenum target,
                                                    GLenum attachment,
                                                    GLenum textarget,
                                                    GLuint texture,
                                                    GLint level) { … }

void GLES2TraceImplementation::FramebufferTextureLayer(GLenum target,
                                                       GLenum attachment,
                                                       GLuint texture,
                                                       GLint level,
                                                       GLint layer) { … }

void GLES2TraceImplementation::FrontFace(GLenum mode) { … }

void GLES2TraceImplementation::GenBuffers(GLsizei n, GLuint* buffers) { … }

void GLES2TraceImplementation::GenerateMipmap(GLenum target) { … }

void GLES2TraceImplementation::GenFramebuffers(GLsizei n,
                                               GLuint* framebuffers) { … }

void GLES2TraceImplementation::GenRenderbuffers(GLsizei n,
                                                GLuint* renderbuffers) { … }

void GLES2TraceImplementation::GenSamplers(GLsizei n, GLuint* samplers) { … }

void GLES2TraceImplementation::GenTextures(GLsizei n, GLuint* textures) { … }

void GLES2TraceImplementation::GenTransformFeedbacks(GLsizei n, GLuint* ids) { … }

void GLES2TraceImplementation::GetActiveAttrib(GLuint program,
                                               GLuint index,
                                               GLsizei bufsize,
                                               GLsizei* length,
                                               GLint* size,
                                               GLenum* type,
                                               char* name) { … }

void GLES2TraceImplementation::GetActiveUniform(GLuint program,
                                                GLuint index,
                                                GLsizei bufsize,
                                                GLsizei* length,
                                                GLint* size,
                                                GLenum* type,
                                                char* name) { … }

void GLES2TraceImplementation::GetActiveUniformBlockiv(GLuint program,
                                                       GLuint index,
                                                       GLenum pname,
                                                       GLint* params) { … }

void GLES2TraceImplementation::GetActiveUniformBlockName(GLuint program,
                                                         GLuint index,
                                                         GLsizei bufsize,
                                                         GLsizei* length,
                                                         char* name) { … }

void GLES2TraceImplementation::GetActiveUniformsiv(GLuint program,
                                                   GLsizei count,
                                                   const GLuint* indices,
                                                   GLenum pname,
                                                   GLint* params) { … }

void GLES2TraceImplementation::GetAttachedShaders(GLuint program,
                                                  GLsizei maxcount,
                                                  GLsizei* count,
                                                  GLuint* shaders) { … }

GLint GLES2TraceImplementation::GetAttribLocation(GLuint program,
                                                  const char* name) { … }

void GLES2TraceImplementation::GetBooleanv(GLenum pname, GLboolean* params) { … }

void GLES2TraceImplementation::GetBooleani_v(GLenum pname,
                                             GLuint index,
                                             GLboolean* data) { … }

void GLES2TraceImplementation::GetBufferParameteri64v(GLenum target,
                                                      GLenum pname,
                                                      GLint64* params) { … }

void GLES2TraceImplementation::GetBufferParameteriv(GLenum target,
                                                    GLenum pname,
                                                    GLint* params) { … }

GLenum GLES2TraceImplementation::GetError() { … }

void GLES2TraceImplementation::GetFloatv(GLenum pname, GLfloat* params) { … }

GLint GLES2TraceImplementation::GetFragDataLocation(GLuint program,
                                                    const char* name) { … }

void GLES2TraceImplementation::GetFramebufferAttachmentParameteriv(
    GLenum target,
    GLenum attachment,
    GLenum pname,
    GLint* params) { … }

void GLES2TraceImplementation::GetInteger64v(GLenum pname, GLint64* params) { … }

void GLES2TraceImplementation::GetIntegeri_v(GLenum pname,
                                             GLuint index,
                                             GLint* data) { … }

void GLES2TraceImplementation::GetInteger64i_v(GLenum pname,
                                               GLuint index,
                                               GLint64* data) { … }

void GLES2TraceImplementation::GetIntegerv(GLenum pname, GLint* params) { … }

void GLES2TraceImplementation::GetInternalformativ(GLenum target,
                                                   GLenum format,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   GLint* params) { … }

void GLES2TraceImplementation::GetProgramiv(GLuint program,
                                            GLenum pname,
                                            GLint* params) { … }

void GLES2TraceImplementation::GetProgramInfoLog(GLuint program,
                                                 GLsizei bufsize,
                                                 GLsizei* length,
                                                 char* infolog) { … }

void GLES2TraceImplementation::GetRenderbufferParameteriv(GLenum target,
                                                          GLenum pname,
                                                          GLint* params) { … }

void GLES2TraceImplementation::GetSamplerParameterfv(GLuint sampler,
                                                     GLenum pname,
                                                     GLfloat* params) { … }

void GLES2TraceImplementation::GetSamplerParameteriv(GLuint sampler,
                                                     GLenum pname,
                                                     GLint* params) { … }

void GLES2TraceImplementation::GetShaderiv(GLuint shader,
                                           GLenum pname,
                                           GLint* params) { … }

void GLES2TraceImplementation::GetShaderInfoLog(GLuint shader,
                                                GLsizei bufsize,
                                                GLsizei* length,
                                                char* infolog) { … }

void GLES2TraceImplementation::GetShaderPrecisionFormat(GLenum shadertype,
                                                        GLenum precisiontype,
                                                        GLint* range,
                                                        GLint* precision) { … }

void GLES2TraceImplementation::GetShaderSource(GLuint shader,
                                               GLsizei bufsize,
                                               GLsizei* length,
                                               char* source) { … }

const GLubyte* GLES2TraceImplementation::GetString(GLenum name) { … }

const GLubyte* GLES2TraceImplementation::GetStringi(GLenum name, GLuint index) { … }

void GLES2TraceImplementation::GetSynciv(GLsync sync,
                                         GLenum pname,
                                         GLsizei bufsize,
                                         GLsizei* length,
                                         GLint* values) { … }

void GLES2TraceImplementation::GetTexParameterfv(GLenum target,
                                                 GLenum pname,
                                                 GLfloat* params) { … }

void GLES2TraceImplementation::GetTexParameteriv(GLenum target,
                                                 GLenum pname,
                                                 GLint* params) { … }

void GLES2TraceImplementation::GetTransformFeedbackVarying(GLuint program,
                                                           GLuint index,
                                                           GLsizei bufsize,
                                                           GLsizei* length,
                                                           GLsizei* size,
                                                           GLenum* type,
                                                           char* name) { … }

GLuint GLES2TraceImplementation::GetUniformBlockIndex(GLuint program,
                                                      const char* name) { … }

void GLES2TraceImplementation::GetUniformfv(GLuint program,
                                            GLint location,
                                            GLfloat* params) { … }

void GLES2TraceImplementation::GetUniformiv(GLuint program,
                                            GLint location,
                                            GLint* params) { … }

void GLES2TraceImplementation::GetUniformuiv(GLuint program,
                                             GLint location,
                                             GLuint* params) { … }

void GLES2TraceImplementation::GetUniformIndices(GLuint program,
                                                 GLsizei count,
                                                 const char* const* names,
                                                 GLuint* indices) { … }

GLint GLES2TraceImplementation::GetUniformLocation(GLuint program,
                                                   const char* name) { … }

void GLES2TraceImplementation::GetVertexAttribfv(GLuint index,
                                                 GLenum pname,
                                                 GLfloat* params) { … }

void GLES2TraceImplementation::GetVertexAttribiv(GLuint index,
                                                 GLenum pname,
                                                 GLint* params) { … }

void GLES2TraceImplementation::GetVertexAttribIiv(GLuint index,
                                                  GLenum pname,
                                                  GLint* params) { … }

void GLES2TraceImplementation::GetVertexAttribIuiv(GLuint index,
                                                   GLenum pname,
                                                   GLuint* params) { … }

void GLES2TraceImplementation::GetVertexAttribPointerv(GLuint index,
                                                       GLenum pname,
                                                       void** pointer) { … }

void GLES2TraceImplementation::Hint(GLenum target, GLenum mode) { … }

void GLES2TraceImplementation::InvalidateFramebuffer(
    GLenum target,
    GLsizei count,
    const GLenum* attachments) { … }

void GLES2TraceImplementation::InvalidateSubFramebuffer(
    GLenum target,
    GLsizei count,
    const GLenum* attachments,
    GLint x,
    GLint y,
    GLsizei width,
    GLsizei height) { … }

GLboolean GLES2TraceImplementation::IsBuffer(GLuint buffer) { … }

GLboolean GLES2TraceImplementation::IsEnabled(GLenum cap) { … }

GLboolean GLES2TraceImplementation::IsFramebuffer(GLuint framebuffer) { … }

GLboolean GLES2TraceImplementation::IsProgram(GLuint program) { … }

GLboolean GLES2TraceImplementation::IsRenderbuffer(GLuint renderbuffer) { … }

GLboolean GLES2TraceImplementation::IsSampler(GLuint sampler) { … }

GLboolean GLES2TraceImplementation::IsShader(GLuint shader) { … }

GLboolean GLES2TraceImplementation::IsSync(GLsync sync) { … }

GLboolean GLES2TraceImplementation::IsTexture(GLuint texture) { … }

GLboolean GLES2TraceImplementation::IsTransformFeedback(
    GLuint transformfeedback) { … }

void GLES2TraceImplementation::LineWidth(GLfloat width) { … }

void GLES2TraceImplementation::LinkProgram(GLuint program) { … }

void GLES2TraceImplementation::PauseTransformFeedback() { … }

void GLES2TraceImplementation::PixelStorei(GLenum pname, GLint param) { … }

void GLES2TraceImplementation::PolygonOffset(GLfloat factor, GLfloat units) { … }

void GLES2TraceImplementation::ReadBuffer(GLenum src) { … }

void GLES2TraceImplementation::ReadPixels(GLint x,
                                          GLint y,
                                          GLsizei width,
                                          GLsizei height,
                                          GLenum format,
                                          GLenum type,
                                          void* pixels) { … }

void GLES2TraceImplementation::ReleaseShaderCompiler() { … }

void GLES2TraceImplementation::RenderbufferStorage(GLenum target,
                                                   GLenum internalformat,
                                                   GLsizei width,
                                                   GLsizei height) { … }

void GLES2TraceImplementation::ResumeTransformFeedback() { … }

void GLES2TraceImplementation::SampleCoverage(GLclampf value,
                                              GLboolean invert) { … }

void GLES2TraceImplementation::SamplerParameterf(GLuint sampler,
                                                 GLenum pname,
                                                 GLfloat param) { … }

void GLES2TraceImplementation::SamplerParameterfv(GLuint sampler,
                                                  GLenum pname,
                                                  const GLfloat* params) { … }

void GLES2TraceImplementation::SamplerParameteri(GLuint sampler,
                                                 GLenum pname,
                                                 GLint param) { … }

void GLES2TraceImplementation::SamplerParameteriv(GLuint sampler,
                                                  GLenum pname,
                                                  const GLint* params) { … }

void GLES2TraceImplementation::Scissor(GLint x,
                                       GLint y,
                                       GLsizei width,
                                       GLsizei height) { … }

void GLES2TraceImplementation::ShaderBinary(GLsizei n,
                                            const GLuint* shaders,
                                            GLenum binaryformat,
                                            const void* binary,
                                            GLsizei length) { … }

void GLES2TraceImplementation::ShaderSource(GLuint shader,
                                            GLsizei count,
                                            const GLchar* const* str,
                                            const GLint* length) { … }

void GLES2TraceImplementation::ShallowFinishCHROMIUM() { … }

void GLES2TraceImplementation::OrderingBarrierCHROMIUM() { … }

void GLES2TraceImplementation::MultiDrawArraysWEBGL(GLenum mode,
                                                    const GLint* firsts,
                                                    const GLsizei* counts,
                                                    GLsizei drawcount) { … }

void GLES2TraceImplementation::MultiDrawArraysInstancedWEBGL(
    GLenum mode,
    const GLint* firsts,
    const GLsizei* counts,
    const GLsizei* instance_counts,
    GLsizei drawcount) { … }

void GLES2TraceImplementation::MultiDrawArraysInstancedBaseInstanceWEBGL(
    GLenum mode,
    const GLint* firsts,
    const GLsizei* counts,
    const GLsizei* instance_counts,
    const GLuint* baseinstances,
    GLsizei drawcount) { … }

void GLES2TraceImplementation::MultiDrawElementsWEBGL(GLenum mode,
                                                      const GLsizei* counts,
                                                      GLenum type,
                                                      const GLsizei* offsets,
                                                      GLsizei drawcount) { … }

void GLES2TraceImplementation::MultiDrawElementsInstancedWEBGL(
    GLenum mode,
    const GLsizei* counts,
    GLenum type,
    const GLsizei* offsets,
    const GLsizei* instance_counts,
    GLsizei drawcount) { … }

void GLES2TraceImplementation::
    MultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL(
        GLenum mode,
        const GLsizei* counts,
        GLenum type,
        const GLsizei* offsets,
        const GLsizei* instance_counts,
        const GLint* basevertices,
        const GLuint* baseinstances,
        GLsizei drawcount) { … }

void GLES2TraceImplementation::StencilFunc(GLenum func,
                                           GLint ref,
                                           GLuint mask) { … }

void GLES2TraceImplementation::StencilFuncSeparate(GLenum face,
                                                   GLenum func,
                                                   GLint ref,
                                                   GLuint mask) { … }

void GLES2TraceImplementation::StencilMask(GLuint mask) { … }

void GLES2TraceImplementation::StencilMaskSeparate(GLenum face, GLuint mask) { … }

void GLES2TraceImplementation::StencilOp(GLenum fail,
                                         GLenum zfail,
                                         GLenum zpass) { … }

void GLES2TraceImplementation::StencilOpSeparate(GLenum face,
                                                 GLenum fail,
                                                 GLenum zfail,
                                                 GLenum zpass) { … }

void GLES2TraceImplementation::TexImage2D(GLenum target,
                                          GLint level,
                                          GLint internalformat,
                                          GLsizei width,
                                          GLsizei height,
                                          GLint border,
                                          GLenum format,
                                          GLenum type,
                                          const void* pixels) { … }

void GLES2TraceImplementation::TexImage3D(GLenum target,
                                          GLint level,
                                          GLint internalformat,
                                          GLsizei width,
                                          GLsizei height,
                                          GLsizei depth,
                                          GLint border,
                                          GLenum format,
                                          GLenum type,
                                          const void* pixels) { … }

void GLES2TraceImplementation::TexParameterf(GLenum target,
                                             GLenum pname,
                                             GLfloat param) { … }

void GLES2TraceImplementation::TexParameterfv(GLenum target,
                                              GLenum pname,
                                              const GLfloat* params) { … }

void GLES2TraceImplementation::TexParameteri(GLenum target,
                                             GLenum pname,
                                             GLint param) { … }

void GLES2TraceImplementation::TexParameteriv(GLenum target,
                                              GLenum pname,
                                              const GLint* params) { … }

void GLES2TraceImplementation::TexStorage3D(GLenum target,
                                            GLsizei levels,
                                            GLenum internalFormat,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth) { … }

void GLES2TraceImplementation::TexSubImage2D(GLenum target,
                                             GLint level,
                                             GLint xoffset,
                                             GLint yoffset,
                                             GLsizei width,
                                             GLsizei height,
                                             GLenum format,
                                             GLenum type,
                                             const void* pixels) { … }

void GLES2TraceImplementation::TexSubImage3D(GLenum target,
                                             GLint level,
                                             GLint xoffset,
                                             GLint yoffset,
                                             GLint zoffset,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLenum format,
                                             GLenum type,
                                             const void* pixels) { … }

void GLES2TraceImplementation::TransformFeedbackVaryings(
    GLuint program,
    GLsizei count,
    const char* const* varyings,
    GLenum buffermode) { … }

void GLES2TraceImplementation::Uniform1f(GLint location, GLfloat x) { … }

void GLES2TraceImplementation::Uniform1fv(GLint location,
                                          GLsizei count,
                                          const GLfloat* v) { … }

void GLES2TraceImplementation::Uniform1i(GLint location, GLint x) { … }

void GLES2TraceImplementation::Uniform1iv(GLint location,
                                          GLsizei count,
                                          const GLint* v) { … }

void GLES2TraceImplementation::Uniform1ui(GLint location, GLuint x) { … }

void GLES2TraceImplementation::Uniform1uiv(GLint location,
                                           GLsizei count,
                                           const GLuint* v) { … }

void GLES2TraceImplementation::Uniform2f(GLint location, GLfloat x, GLfloat y) { … }

void GLES2TraceImplementation::Uniform2fv(GLint location,
                                          GLsizei count,
                                          const GLfloat* v) { … }

void GLES2TraceImplementation::Uniform2i(GLint location, GLint x, GLint y) { … }

void GLES2TraceImplementation::Uniform2iv(GLint location,
                                          GLsizei count,
                                          const GLint* v) { … }

void GLES2TraceImplementation::Uniform2ui(GLint location, GLuint x, GLuint y) { … }

void GLES2TraceImplementation::Uniform2uiv(GLint location,
                                           GLsizei count,
                                           const GLuint* v) { … }

void GLES2TraceImplementation::Uniform3f(GLint location,
                                         GLfloat x,
                                         GLfloat y,
                                         GLfloat z) { … }

void GLES2TraceImplementation::Uniform3fv(GLint location,
                                          GLsizei count,
                                          const GLfloat* v) { … }

void GLES2TraceImplementation::Uniform3i(GLint location,
                                         GLint x,
                                         GLint y,
                                         GLint z) { … }

void GLES2TraceImplementation::Uniform3iv(GLint location,
                                          GLsizei count,
                                          const GLint* v) { … }

void GLES2TraceImplementation::Uniform3ui(GLint location,
                                          GLuint x,
                                          GLuint y,
                                          GLuint z) { … }

void GLES2TraceImplementation::Uniform3uiv(GLint location,
                                           GLsizei count,
                                           const GLuint* v) { … }

void GLES2TraceImplementation::Uniform4f(GLint location,
                                         GLfloat x,
                                         GLfloat y,
                                         GLfloat z,
                                         GLfloat w) { … }

void GLES2TraceImplementation::Uniform4fv(GLint location,
                                          GLsizei count,
                                          const GLfloat* v) { … }

void GLES2TraceImplementation::Uniform4i(GLint location,
                                         GLint x,
                                         GLint y,
                                         GLint z,
                                         GLint w) { … }

void GLES2TraceImplementation::Uniform4iv(GLint location,
                                          GLsizei count,
                                          const GLint* v) { … }

void GLES2TraceImplementation::Uniform4ui(GLint location,
                                          GLuint x,
                                          GLuint y,
                                          GLuint z,
                                          GLuint w) { … }

void GLES2TraceImplementation::Uniform4uiv(GLint location,
                                           GLsizei count,
                                           const GLuint* v) { … }

void GLES2TraceImplementation::UniformBlockBinding(GLuint program,
                                                   GLuint index,
                                                   GLuint binding) { … }

void GLES2TraceImplementation::UniformMatrix2fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat* value) { … }

void GLES2TraceImplementation::UniformMatrix2x3fv(GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GLES2TraceImplementation::UniformMatrix2x4fv(GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GLES2TraceImplementation::UniformMatrix3fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat* value) { … }

void GLES2TraceImplementation::UniformMatrix3x2fv(GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GLES2TraceImplementation::UniformMatrix3x4fv(GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GLES2TraceImplementation::UniformMatrix4fv(GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat* value) { … }

void GLES2TraceImplementation::UniformMatrix4x2fv(GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GLES2TraceImplementation::UniformMatrix4x3fv(GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GLES2TraceImplementation::UseProgram(GLuint program) { … }

void GLES2TraceImplementation::ValidateProgram(GLuint program) { … }

void GLES2TraceImplementation::VertexAttrib1f(GLuint indx, GLfloat x) { … }

void GLES2TraceImplementation::VertexAttrib1fv(GLuint indx,
                                               const GLfloat* values) { … }

void GLES2TraceImplementation::VertexAttrib2f(GLuint indx,
                                              GLfloat x,
                                              GLfloat y) { … }

void GLES2TraceImplementation::VertexAttrib2fv(GLuint indx,
                                               const GLfloat* values) { … }

void GLES2TraceImplementation::VertexAttrib3f(GLuint indx,
                                              GLfloat x,
                                              GLfloat y,
                                              GLfloat z) { … }

void GLES2TraceImplementation::VertexAttrib3fv(GLuint indx,
                                               const GLfloat* values) { … }

void GLES2TraceImplementation::VertexAttrib4f(GLuint indx,
                                              GLfloat x,
                                              GLfloat y,
                                              GLfloat z,
                                              GLfloat w) { … }

void GLES2TraceImplementation::VertexAttrib4fv(GLuint indx,
                                               const GLfloat* values) { … }

void GLES2TraceImplementation::VertexAttribI4i(GLuint indx,
                                               GLint x,
                                               GLint y,
                                               GLint z,
                                               GLint w) { … }

void GLES2TraceImplementation::VertexAttribI4iv(GLuint indx,
                                                const GLint* values) { … }

void GLES2TraceImplementation::VertexAttribI4ui(GLuint indx,
                                                GLuint x,
                                                GLuint y,
                                                GLuint z,
                                                GLuint w) { … }

void GLES2TraceImplementation::VertexAttribI4uiv(GLuint indx,
                                                 const GLuint* values) { … }

void GLES2TraceImplementation::VertexAttribIPointer(GLuint indx,
                                                    GLint size,
                                                    GLenum type,
                                                    GLsizei stride,
                                                    const void* ptr) { … }

void GLES2TraceImplementation::VertexAttribPointer(GLuint indx,
                                                   GLint size,
                                                   GLenum type,
                                                   GLboolean normalized,
                                                   GLsizei stride,
                                                   const void* ptr) { … }

void GLES2TraceImplementation::Viewport(GLint x,
                                        GLint y,
                                        GLsizei width,
                                        GLsizei height) { … }

void GLES2TraceImplementation::WaitSync(GLsync sync,
                                        GLbitfield flags,
                                        GLuint64 timeout) { … }

void GLES2TraceImplementation::BlitFramebufferCHROMIUM(GLint srcX0,
                                                       GLint srcY0,
                                                       GLint srcX1,
                                                       GLint srcY1,
                                                       GLint dstX0,
                                                       GLint dstY0,
                                                       GLint dstX1,
                                                       GLint dstY1,
                                                       GLbitfield mask,
                                                       GLenum filter) { … }

void GLES2TraceImplementation::RenderbufferStorageMultisampleCHROMIUM(
    GLenum target,
    GLsizei samples,
    GLenum internalformat,
    GLsizei width,
    GLsizei height) { … }

void GLES2TraceImplementation::RenderbufferStorageMultisampleAdvancedAMD(
    GLenum target,
    GLsizei samples,
    GLsizei storageSamples,
    GLenum internalformat,
    GLsizei width,
    GLsizei height) { … }

void GLES2TraceImplementation::RenderbufferStorageMultisampleEXT(
    GLenum target,
    GLsizei samples,
    GLenum internalformat,
    GLsizei width,
    GLsizei height) { … }

void GLES2TraceImplementation::FramebufferTexture2DMultisampleEXT(
    GLenum target,
    GLenum attachment,
    GLenum textarget,
    GLuint texture,
    GLint level,
    GLsizei samples) { … }

void GLES2TraceImplementation::TexStorage2DEXT(GLenum target,
                                               GLsizei levels,
                                               GLenum internalFormat,
                                               GLsizei width,
                                               GLsizei height) { … }

void GLES2TraceImplementation::GenQueriesEXT(GLsizei n, GLuint* queries) { … }

void GLES2TraceImplementation::DeleteQueriesEXT(GLsizei n,
                                                const GLuint* queries) { … }

void GLES2TraceImplementation::QueryCounterEXT(GLuint id, GLenum target) { … }

GLboolean GLES2TraceImplementation::IsQueryEXT(GLuint id) { … }

void GLES2TraceImplementation::BeginQueryEXT(GLenum target, GLuint id) { … }

void GLES2TraceImplementation::BeginTransformFeedback(GLenum primitivemode) { … }

void GLES2TraceImplementation::EndQueryEXT(GLenum target) { … }

void GLES2TraceImplementation::EndTransformFeedback() { … }

void GLES2TraceImplementation::GetQueryivEXT(GLenum target,
                                             GLenum pname,
                                             GLint* params) { … }

void GLES2TraceImplementation::GetQueryObjectivEXT(GLuint id,
                                                   GLenum pname,
                                                   GLint* params) { … }

void GLES2TraceImplementation::GetQueryObjectuivEXT(GLuint id,
                                                    GLenum pname,
                                                    GLuint* params) { … }

void GLES2TraceImplementation::GetQueryObjecti64vEXT(GLuint id,
                                                     GLenum pname,
                                                     GLint64* params) { … }

void GLES2TraceImplementation::GetQueryObjectui64vEXT(GLuint id,
                                                      GLenum pname,
                                                      GLuint64* params) { … }

void GLES2TraceImplementation::SetDisjointValueSyncCHROMIUM() { … }

void GLES2TraceImplementation::InsertEventMarkerEXT(GLsizei length,
                                                    const GLchar* marker) { … }

void GLES2TraceImplementation::PushGroupMarkerEXT(GLsizei length,
                                                  const GLchar* marker) { … }

void GLES2TraceImplementation::PopGroupMarkerEXT() { … }

void GLES2TraceImplementation::GenVertexArraysOES(GLsizei n, GLuint* arrays) { … }

void GLES2TraceImplementation::DeleteVertexArraysOES(GLsizei n,
                                                     const GLuint* arrays) { … }

GLboolean GLES2TraceImplementation::IsVertexArrayOES(GLuint array) { … }

void GLES2TraceImplementation::BindVertexArrayOES(GLuint array) { … }

void GLES2TraceImplementation::FramebufferParameteri(GLenum target,
                                                     GLenum pname,
                                                     GLint param) { … }

void GLES2TraceImplementation::BindImageTexture(GLuint unit,
                                                GLuint texture,
                                                GLint level,
                                                GLboolean layered,
                                                GLint layer,
                                                GLenum access,
                                                GLenum format) { … }

void GLES2TraceImplementation::DispatchCompute(GLuint num_groups_x,
                                               GLuint num_groups_y,
                                               GLuint num_groups_z) { … }

void GLES2TraceImplementation::DispatchComputeIndirect(GLintptr offset) { … }

void GLES2TraceImplementation::DrawArraysIndirect(GLenum mode,
                                                  const void* offset) { … }

void GLES2TraceImplementation::DrawElementsIndirect(GLenum mode,
                                                    GLenum type,
                                                    const void* offset) { … }

void GLES2TraceImplementation::GetProgramInterfaceiv(GLuint program,
                                                     GLenum program_interface,
                                                     GLenum pname,
                                                     GLint* params) { … }

GLuint GLES2TraceImplementation::GetProgramResourceIndex(
    GLuint program,
    GLenum program_interface,
    const char* name) { … }

void GLES2TraceImplementation::GetProgramResourceName(GLuint program,
                                                      GLenum program_interface,
                                                      GLuint index,
                                                      GLsizei bufsize,
                                                      GLsizei* length,
                                                      char* name) { … }

void GLES2TraceImplementation::GetProgramResourceiv(GLuint program,
                                                    GLenum program_interface,
                                                    GLuint index,
                                                    GLsizei prop_count,
                                                    const GLenum* props,
                                                    GLsizei bufsize,
                                                    GLsizei* length,
                                                    GLint* params) { … }

GLint GLES2TraceImplementation::GetProgramResourceLocation(
    GLuint program,
    GLenum program_interface,
    const char* name) { … }

void GLES2TraceImplementation::MemoryBarrierEXT(GLbitfield barriers) { … }

void GLES2TraceImplementation::MemoryBarrierByRegion(GLbitfield barriers) { … }

void GLES2TraceImplementation::SwapBuffers(GLuint64 swap_id, GLbitfield flags) { … }

GLuint GLES2TraceImplementation::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
                                                             GLsizei count,
                                                             GLenum type,
                                                             GLuint offset) { … }

GLboolean GLES2TraceImplementation::EnableFeatureCHROMIUM(const char* feature) { … }

void* GLES2TraceImplementation::MapBufferCHROMIUM(GLuint target,
                                                  GLenum access) { … }

GLboolean GLES2TraceImplementation::UnmapBufferCHROMIUM(GLuint target) { … }

void* GLES2TraceImplementation::MapBufferSubDataCHROMIUM(GLuint target,
                                                         GLintptr offset,
                                                         GLsizeiptr size,
                                                         GLenum access) { … }

void GLES2TraceImplementation::UnmapBufferSubDataCHROMIUM(const void* mem) { … }

void* GLES2TraceImplementation::MapBufferRange(GLenum target,
                                               GLintptr offset,
                                               GLsizeiptr size,
                                               GLbitfield access) { … }

GLboolean GLES2TraceImplementation::UnmapBuffer(GLenum target) { … }

void GLES2TraceImplementation::FlushMappedBufferRange(GLenum target,
                                                      GLintptr offset,
                                                      GLsizeiptr size) { … }

void* GLES2TraceImplementation::MapTexSubImage2DCHROMIUM(GLenum target,
                                                         GLint level,
                                                         GLint xoffset,
                                                         GLint yoffset,
                                                         GLsizei width,
                                                         GLsizei height,
                                                         GLenum format,
                                                         GLenum type,
                                                         GLenum access) { … }

void GLES2TraceImplementation::UnmapTexSubImage2DCHROMIUM(const void* mem) { … }

void GLES2TraceImplementation::ResizeCHROMIUM(GLuint width,
                                              GLuint height,
                                              GLfloat scale_factor,
                                              GLcolorSpace color_space,
                                              GLboolean alpha) { … }

const GLchar* GLES2TraceImplementation::GetRequestableExtensionsCHROMIUM() { … }

void GLES2TraceImplementation::RequestExtensionCHROMIUM(const char* extension) { … }

void GLES2TraceImplementation::GetProgramInfoCHROMIUM(GLuint program,
                                                      GLsizei bufsize,
                                                      GLsizei* size,
                                                      void* info) { … }

void GLES2TraceImplementation::GetUniformBlocksCHROMIUM(GLuint program,
                                                        GLsizei bufsize,
                                                        GLsizei* size,
                                                        void* info) { … }

void GLES2TraceImplementation::GetTransformFeedbackVaryingsCHROMIUM(
    GLuint program,
    GLsizei bufsize,
    GLsizei* size,
    void* info) { … }

void GLES2TraceImplementation::GetUniformsES3CHROMIUM(GLuint program,
                                                      GLsizei bufsize,
                                                      GLsizei* size,
                                                      void* info) { … }

void GLES2TraceImplementation::DescheduleUntilFinishedCHROMIUM() { … }

void GLES2TraceImplementation::GetTranslatedShaderSourceANGLE(GLuint shader,
                                                              GLsizei bufsize,
                                                              GLsizei* length,
                                                              char* source) { … }

void GLES2TraceImplementation::CopyTextureCHROMIUM(
    GLuint source_id,
    GLint source_level,
    GLenum dest_target,
    GLuint dest_id,
    GLint dest_level,
    GLint internalformat,
    GLenum dest_type,
    GLboolean unpack_flip_y,
    GLboolean unpack_premultiply_alpha,
    GLboolean unpack_unmultiply_alpha) { … }

void GLES2TraceImplementation::CopySubTextureCHROMIUM(
    GLuint source_id,
    GLint source_level,
    GLenum dest_target,
    GLuint dest_id,
    GLint dest_level,
    GLint xoffset,
    GLint yoffset,
    GLint x,
    GLint y,
    GLsizei width,
    GLsizei height,
    GLboolean unpack_flip_y,
    GLboolean unpack_premultiply_alpha,
    GLboolean unpack_unmultiply_alpha) { … }

void GLES2TraceImplementation::DrawArraysInstancedANGLE(GLenum mode,
                                                        GLint first,
                                                        GLsizei count,
                                                        GLsizei primcount) { … }

void GLES2TraceImplementation::DrawArraysInstancedBaseInstanceANGLE(
    GLenum mode,
    GLint first,
    GLsizei count,
    GLsizei primcount,
    GLuint baseinstance) { … }

void GLES2TraceImplementation::DrawElementsInstancedANGLE(GLenum mode,
                                                          GLsizei count,
                                                          GLenum type,
                                                          const void* indices,
                                                          GLsizei primcount) { … }

void GLES2TraceImplementation::DrawElementsInstancedBaseVertexBaseInstanceANGLE(
    GLenum mode,
    GLsizei count,
    GLenum type,
    const void* indices,
    GLsizei primcount,
    GLint basevertex,
    GLuint baseinstance) { … }

void GLES2TraceImplementation::VertexAttribDivisorANGLE(GLuint index,
                                                        GLuint divisor) { … }

void GLES2TraceImplementation::BindUniformLocationCHROMIUM(GLuint program,
                                                           GLint location,
                                                           const char* name) { … }

void GLES2TraceImplementation::TraceBeginCHROMIUM(const char* category_name,
                                                  const char* trace_name) { … }

void GLES2TraceImplementation::TraceEndCHROMIUM() { … }

void GLES2TraceImplementation::DiscardFramebufferEXT(
    GLenum target,
    GLsizei count,
    const GLenum* attachments) { … }

void GLES2TraceImplementation::LoseContextCHROMIUM(GLenum current,
                                                   GLenum other) { … }

void GLES2TraceImplementation::DrawBuffersEXT(GLsizei count,
                                              const GLenum* bufs) { … }

void GLES2TraceImplementation::FlushDriverCachesCHROMIUM() { … }

GLuint GLES2TraceImplementation::GetLastFlushIdCHROMIUM() { … }

void GLES2TraceImplementation::SetActiveURLCHROMIUM(const char* url) { … }

void GLES2TraceImplementation::ContextVisibilityHintCHROMIUM(
    GLboolean visibility) { … }

GLenum GLES2TraceImplementation::GetGraphicsResetStatusKHR() { … }

void GLES2TraceImplementation::BlendBarrierKHR() { … }

void GLES2TraceImplementation::BindFragDataLocationIndexedEXT(
    GLuint program,
    GLuint colorNumber,
    GLuint index,
    const char* name) { … }

void GLES2TraceImplementation::BindFragDataLocationEXT(GLuint program,
                                                       GLuint colorNumber,
                                                       const char* name) { … }

GLint GLES2TraceImplementation::GetFragDataIndexEXT(GLuint program,
                                                    const char* name) { … }

void GLES2TraceImplementation::InitializeDiscardableTextureCHROMIUM(
    GLuint texture_id) { … }

void GLES2TraceImplementation::UnlockDiscardableTextureCHROMIUM(
    GLuint texture_id) { … }

bool GLES2TraceImplementation::LockDiscardableTextureCHROMIUM(
    GLuint texture_id) { … }

void GLES2TraceImplementation::WindowRectanglesEXT(GLenum mode,
                                                   GLsizei count,
                                                   const GLint* box) { … }

GLuint GLES2TraceImplementation::CreateGpuFenceCHROMIUM() { … }

GLuint GLES2TraceImplementation::CreateClientGpuFenceCHROMIUM(
    ClientGpuFence source) { … }

void GLES2TraceImplementation::WaitGpuFenceCHROMIUM(GLuint gpu_fence_id) { … }

void GLES2TraceImplementation::DestroyGpuFenceCHROMIUM(GLuint gpu_fence_id) { … }

void GLES2TraceImplementation::InvalidateReadbackBufferShadowDataCHROMIUM(
    GLuint buffer_id) { … }

void GLES2TraceImplementation::FramebufferTextureMultiviewOVR(
    GLenum target,
    GLenum attachment,
    GLuint texture,
    GLint level,
    GLint baseViewIndex,
    GLsizei numViews) { … }

void GLES2TraceImplementation::MaxShaderCompilerThreadsKHR(GLuint count) { … }

GLuint GLES2TraceImplementation::CreateAndTexStorage2DSharedImageCHROMIUM(
    const GLbyte* mailbox) { … }

void GLES2TraceImplementation::BeginSharedImageAccessDirectCHROMIUM(
    GLuint texture,
    GLenum mode) { … }

void GLES2TraceImplementation::EndSharedImageAccessDirectCHROMIUM(
    GLuint texture) { … }

void GLES2TraceImplementation::ConvertRGBAToYUVAMailboxesINTERNAL(
    GLenum planes_yuv_color_space,
    GLenum plane_config,
    GLenum subsampling,
    const GLbyte* mailboxes) { … }

void GLES2TraceImplementation::ConvertYUVAMailboxesToRGBINTERNAL(
    GLint src_x,
    GLint src_y,
    GLsizei width,
    GLsizei height,
    GLenum planes_yuv_color_space,
    GLenum plane_config,
    GLenum subsampling,
    const GLbyte* mailboxes) { … }

void GLES2TraceImplementation::ConvertYUVAMailboxesToTextureINTERNAL(
    GLuint texture,
    GLenum target,
    GLuint internal_format,
    GLenum type,
    GLint src_x,
    GLint src_y,
    GLsizei width,
    GLsizei height,
    GLboolean flip_y,
    GLenum planes_yuv_color_space,
    GLenum plane_config,
    GLenum subsampling,
    const GLbyte* mailboxes) { … }

void GLES2TraceImplementation::CopySharedImageINTERNAL(
    GLint xoffset,
    GLint yoffset,
    GLint x,
    GLint y,
    GLsizei width,
    GLsizei height,
    GLboolean unpack_flip_y,
    const GLbyte* mailboxes) { … }

void GLES2TraceImplementation::CopySharedImageToTextureINTERNAL(
    GLuint texture,
    GLenum target,
    GLuint internal_format,
    GLenum type,
    GLint src_x,
    GLint src_y,
    GLsizei width,
    GLsizei height,
    GLboolean flip_y,
    const GLbyte* src_mailbox) { … }

GLboolean GLES2TraceImplementation::ReadbackARGBImagePixelsINTERNAL(
    const GLbyte* mailbox,
    const void* dst_color_space,
    GLuint dst_color_space_size,
    GLuint dst_size,
    GLuint dst_width,
    GLuint dst_height,
    GLuint dst_color_type,
    GLuint dst_alpha_type,
    GLuint dst_row_bytes,
    GLint src_x,
    GLint src_y,
    GLint plane_index,
    void* pixels) { … }

void GLES2TraceImplementation::WritePixelsYUVINTERNAL(
    const GLbyte* mailbox,
    GLuint src_size_plane1,
    GLuint src_size_plane2,
    GLuint src_size_plane3,
    GLuint src_size_plane4,
    GLuint src_width,
    GLuint src_height,
    GLuint src_plane_config,
    GLuint src_subsampling,
    GLuint src_datatype,
    GLuint src_row_bytes_plane1,
    GLuint src_row_bytes_plane2,
    GLuint src_row_bytes_plane3,
    GLuint src_row_bytes_plane4,
    const void* src_pixels_plane1,
    const void* src_pixels_plane2,
    const void* src_pixels_plane3,
    const void* src_pixels_plane4) { … }

void GLES2TraceImplementation::EnableiOES(GLenum target, GLuint index) { … }

void GLES2TraceImplementation::DisableiOES(GLenum target, GLuint index) { … }

void GLES2TraceImplementation::BlendEquationiOES(GLuint buf, GLenum mode) { … }

void GLES2TraceImplementation::BlendEquationSeparateiOES(GLuint buf,
                                                         GLenum modeRGB,
                                                         GLenum modeAlpha) { … }

void GLES2TraceImplementation::BlendFunciOES(GLuint buf,
                                             GLenum src,
                                             GLenum dst) { … }

void GLES2TraceImplementation::BlendFuncSeparateiOES(GLuint buf,
                                                     GLenum srcRGB,
                                                     GLenum dstRGB,
                                                     GLenum srcAlpha,
                                                     GLenum dstAlpha) { … }

void GLES2TraceImplementation::ColorMaskiOES(GLuint buf,
                                             GLboolean r,
                                             GLboolean g,
                                             GLboolean b,
                                             GLboolean a) { … }

GLboolean GLES2TraceImplementation::IsEnablediOES(GLenum target, GLuint index) { … }

void GLES2TraceImplementation::ProvokingVertexANGLE(GLenum provokeMode) { … }

void GLES2TraceImplementation::FramebufferMemorylessPixelLocalStorageANGLE(
    GLint plane,
    GLenum internalformat) { … }

void GLES2TraceImplementation::FramebufferTexturePixelLocalStorageANGLE(
    GLint plane,
    GLuint backingtexture,
    GLint level,
    GLint layer) { … }

void GLES2TraceImplementation::FramebufferPixelLocalClearValuefvANGLE(
    GLint plane,
    const GLfloat* value) { … }

void GLES2TraceImplementation::FramebufferPixelLocalClearValueivANGLE(
    GLint plane,
    const GLint* value) { … }

void GLES2TraceImplementation::FramebufferPixelLocalClearValueuivANGLE(
    GLint plane,
    const GLuint* value) { … }

void GLES2TraceImplementation::BeginPixelLocalStorageANGLE(
    GLsizei count,
    const GLenum* loadops) { … }

void GLES2TraceImplementation::EndPixelLocalStorageANGLE(
    GLsizei count,
    const GLenum* storeops) { … }

void GLES2TraceImplementation::PixelLocalStorageBarrierANGLE() { … }

void GLES2TraceImplementation::FramebufferPixelLocalStorageInterruptANGLE() { … }

void GLES2TraceImplementation::FramebufferPixelLocalStorageRestoreANGLE() { … }

void GLES2TraceImplementation::GetFramebufferPixelLocalStorageParameterfvANGLE(
    GLint plane,
    GLenum pname,
    GLfloat* params) { … }

void GLES2TraceImplementation::GetFramebufferPixelLocalStorageParameterivANGLE(
    GLint plane,
    GLenum pname,
    GLint* params) { … }

void GLES2TraceImplementation::ClipControlEXT(GLenum origin, GLenum depth) { … }

void GLES2TraceImplementation::PolygonModeANGLE(GLenum face, GLenum mode) { … }

void GLES2TraceImplementation::PolygonOffsetClampEXT(GLfloat factor,
                                                     GLfloat units,
                                                     GLfloat clamp) { … }

#endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_TRACE_IMPLEMENTATION_IMPL_AUTOGEN_H_