root/mojo/examples/pepper_container_app/ppb_opengles2_thunk.cc

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. IsBoundGraphics
  2. ActiveTexture
  3. AttachShader
  4. BindAttribLocation
  5. BindBuffer
  6. BindFramebuffer
  7. BindRenderbuffer
  8. BindTexture
  9. BlendColor
  10. BlendEquation
  11. BlendEquationSeparate
  12. BlendFunc
  13. BlendFuncSeparate
  14. BufferData
  15. BufferSubData
  16. CheckFramebufferStatus
  17. Clear
  18. ClearColor
  19. ClearDepthf
  20. ClearStencil
  21. ColorMask
  22. CompileShader
  23. CompressedTexImage2D
  24. CompressedTexSubImage2D
  25. CopyTexImage2D
  26. CopyTexSubImage2D
  27. CreateProgram
  28. CreateShader
  29. CullFace
  30. DeleteBuffers
  31. DeleteFramebuffers
  32. DeleteProgram
  33. DeleteRenderbuffers
  34. DeleteShader
  35. DeleteTextures
  36. DepthFunc
  37. DepthMask
  38. DepthRangef
  39. DetachShader
  40. Disable
  41. DisableVertexAttribArray
  42. DrawArrays
  43. DrawElements
  44. Enable
  45. EnableVertexAttribArray
  46. Finish
  47. Flush
  48. FramebufferRenderbuffer
  49. FramebufferTexture2D
  50. FrontFace
  51. GenBuffers
  52. GenerateMipmap
  53. GenFramebuffers
  54. GenRenderbuffers
  55. GenTextures
  56. GetActiveAttrib
  57. GetActiveUniform
  58. GetAttachedShaders
  59. GetAttribLocation
  60. GetBooleanv
  61. GetBufferParameteriv
  62. GetError
  63. GetFloatv
  64. GetFramebufferAttachmentParameteriv
  65. GetIntegerv
  66. GetProgramiv
  67. GetProgramInfoLog
  68. GetRenderbufferParameteriv
  69. GetShaderiv
  70. GetShaderInfoLog
  71. GetShaderPrecisionFormat
  72. GetShaderSource
  73. GetString
  74. GetTexParameterfv
  75. GetTexParameteriv
  76. GetUniformfv
  77. GetUniformiv
  78. GetUniformLocation
  79. GetVertexAttribfv
  80. GetVertexAttribiv
  81. GetVertexAttribPointerv
  82. Hint
  83. IsBuffer
  84. IsEnabled
  85. IsFramebuffer
  86. IsProgram
  87. IsRenderbuffer
  88. IsShader
  89. IsTexture
  90. LineWidth
  91. LinkProgram
  92. PixelStorei
  93. PolygonOffset
  94. ReadPixels
  95. ReleaseShaderCompiler
  96. RenderbufferStorage
  97. SampleCoverage
  98. Scissor
  99. ShaderBinary
  100. ShaderSource
  101. StencilFunc
  102. StencilFuncSeparate
  103. StencilMask
  104. StencilMaskSeparate
  105. StencilOp
  106. StencilOpSeparate
  107. TexImage2D
  108. TexParameterf
  109. TexParameterfv
  110. TexParameteri
  111. TexParameteriv
  112. TexSubImage2D
  113. Uniform1f
  114. Uniform1fv
  115. Uniform1i
  116. Uniform1iv
  117. Uniform2f
  118. Uniform2fv
  119. Uniform2i
  120. Uniform2iv
  121. Uniform3f
  122. Uniform3fv
  123. Uniform3i
  124. Uniform3iv
  125. Uniform4f
  126. Uniform4fv
  127. Uniform4i
  128. Uniform4iv
  129. UniformMatrix2fv
  130. UniformMatrix3fv
  131. UniformMatrix4fv
  132. UseProgram
  133. ValidateProgram
  134. VertexAttrib1f
  135. VertexAttrib1fv
  136. VertexAttrib2f
  137. VertexAttrib2fv
  138. VertexAttrib3f
  139. VertexAttrib3fv
  140. VertexAttrib4f
  141. VertexAttrib4fv
  142. VertexAttribPointer
  143. Viewport
  144. GetPPB_OpenGLES2_Thunk
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/logging.h"
#include "mojo/examples/pepper_container_app/graphics_3d_resource.h"
#include "mojo/examples/pepper_container_app/thunk.h"
#include "mojo/public/c/gles2/gles2.h"
#include "ppapi/thunk/enter.h"
#include "ppapi/thunk/ppb_graphics_3d_api.h"

namespace mojo {
namespace examples {

namespace {

typedef ppapi::thunk::EnterResource<ppapi::thunk::PPB_Graphics3D_API> Enter3D;

bool IsBoundGraphics(Enter3D* enter) {
  return enter->succeeded() &&
         static_cast<Graphics3DResource*>(enter->object())->IsBoundGraphics();
}

void ActiveTexture(PP_Resource context_id, GLenum texture) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glActiveTexture(texture);
  }
}

void AttachShader(PP_Resource context_id, GLuint program, GLuint shader) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glAttachShader(program, shader);
  }
}

void BindAttribLocation(PP_Resource context_id,
                        GLuint program,
                        GLuint index,
                        const char* name) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBindAttribLocation(program, index, name);
  }
}

void BindBuffer(PP_Resource context_id, GLenum target, GLuint buffer) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBindBuffer(target, buffer);
  }
}

void BindFramebuffer(PP_Resource context_id,
                     GLenum target,
                     GLuint framebuffer) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBindFramebuffer(target, framebuffer);
  }
}

void BindRenderbuffer(PP_Resource context_id,
                      GLenum target,
                      GLuint renderbuffer) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBindRenderbuffer(target, renderbuffer);
  }
}

void BindTexture(PP_Resource context_id, GLenum target, GLuint texture) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBindTexture(target, texture);
  }
}

void BlendColor(PP_Resource context_id,
                GLclampf red,
                GLclampf green,
                GLclampf blue,
                GLclampf alpha) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBlendColor(red, green, blue, alpha);
  }
}

void BlendEquation(PP_Resource context_id, GLenum mode) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBlendEquation(mode);
  }
}

void BlendEquationSeparate(PP_Resource context_id,
                           GLenum modeRGB,
                           GLenum modeAlpha) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBlendEquationSeparate(modeRGB, modeAlpha);
  }
}

void BlendFunc(PP_Resource context_id, GLenum sfactor, GLenum dfactor) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBlendFunc(sfactor, dfactor);
  }
}

void BlendFuncSeparate(PP_Resource context_id,
                       GLenum srcRGB,
                       GLenum dstRGB,
                       GLenum srcAlpha,
                       GLenum dstAlpha) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
  }
}

void BufferData(PP_Resource context_id,
                GLenum target,
                GLsizeiptr size,
                const void* data,
                GLenum usage) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBufferData(target, size, data, usage);
  }
}

void BufferSubData(PP_Resource context_id,
                   GLenum target,
                   GLintptr offset,
                   GLsizeiptr size,
                   const void* data) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glBufferSubData(target, offset, size, data);
  }
}

GLenum CheckFramebufferStatus(PP_Resource context_id, GLenum target) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glCheckFramebufferStatus(target);
  } else {
    return 0;
  }
}

void Clear(PP_Resource context_id, GLbitfield mask) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glClear(mask);
  }
}

void ClearColor(PP_Resource context_id,
                GLclampf red,
                GLclampf green,
                GLclampf blue,
                GLclampf alpha) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glClearColor(red, green, blue, alpha);
  }
}

void ClearDepthf(PP_Resource context_id, GLclampf depth) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glClearDepthf(depth);
  }
}

void ClearStencil(PP_Resource context_id, GLint s) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glClearStencil(s);
  }
}

void ColorMask(PP_Resource context_id,
               GLboolean red,
               GLboolean green,
               GLboolean blue,
               GLboolean alpha) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glColorMask(red, green, blue, alpha);
  }
}

void CompileShader(PP_Resource context_id, GLuint shader) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glCompileShader(shader);
  }
}

void CompressedTexImage2D(PP_Resource context_id,
                          GLenum target,
                          GLint level,
                          GLenum internalformat,
                          GLsizei width,
                          GLsizei height,
                          GLint border,
                          GLsizei imageSize,
                          const void* data) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glCompressedTexImage2D(
        target, level, internalformat, width, height, border, imageSize, data);
  }
}

void CompressedTexSubImage2D(PP_Resource context_id,
                             GLenum target,
                             GLint level,
                             GLint xoffset,
                             GLint yoffset,
                             GLsizei width,
                             GLsizei height,
                             GLenum format,
                             GLsizei imageSize,
                             const void* data) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glCompressedTexSubImage2D(target,
                              level,
                              xoffset,
                              yoffset,
                              width,
                              height,
                              format,
                              imageSize,
                              data);
  }
}

void CopyTexImage2D(PP_Resource context_id,
                    GLenum target,
                    GLint level,
                    GLenum internalformat,
                    GLint x,
                    GLint y,
                    GLsizei width,
                    GLsizei height,
                    GLint border) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glCopyTexImage2D(
        target, level, internalformat, x, y, width, height, border);
  }
}

void CopyTexSubImage2D(PP_Resource context_id,
                       GLenum target,
                       GLint level,
                       GLint xoffset,
                       GLint yoffset,
                       GLint x,
                       GLint y,
                       GLsizei width,
                       GLsizei height) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
  }
}

GLuint CreateProgram(PP_Resource context_id) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glCreateProgram();
  } else {
    return 0;
  }
}

GLuint CreateShader(PP_Resource context_id, GLenum type) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glCreateShader(type);
  } else {
    return 0;
  }
}

void CullFace(PP_Resource context_id, GLenum mode) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glCullFace(mode);
  }
}

void DeleteBuffers(PP_Resource context_id, GLsizei n, const GLuint* buffers) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDeleteBuffers(n, buffers);
  }
}

void DeleteFramebuffers(PP_Resource context_id,
                        GLsizei n,
                        const GLuint* framebuffers) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDeleteFramebuffers(n, framebuffers);
  }
}

void DeleteProgram(PP_Resource context_id, GLuint program) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDeleteProgram(program);
  }
}

void DeleteRenderbuffers(PP_Resource context_id,
                         GLsizei n,
                         const GLuint* renderbuffers) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDeleteRenderbuffers(n, renderbuffers);
  }
}

void DeleteShader(PP_Resource context_id, GLuint shader) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDeleteShader(shader);
  }
}

void DeleteTextures(PP_Resource context_id, GLsizei n, const GLuint* textures) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDeleteTextures(n, textures);
  }
}

void DepthFunc(PP_Resource context_id, GLenum func) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDepthFunc(func);
  }
}

void DepthMask(PP_Resource context_id, GLboolean flag) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDepthMask(flag);
  }
}

void DepthRangef(PP_Resource context_id, GLclampf zNear, GLclampf zFar) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDepthRangef(zNear, zFar);
  }
}

void DetachShader(PP_Resource context_id, GLuint program, GLuint shader) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDetachShader(program, shader);
  }
}

void Disable(PP_Resource context_id, GLenum cap) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDisable(cap);
  }
}

void DisableVertexAttribArray(PP_Resource context_id, GLuint index) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDisableVertexAttribArray(index);
  }
}

void DrawArrays(PP_Resource context_id,
                GLenum mode,
                GLint first,
                GLsizei count) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDrawArrays(mode, first, count);
  }
}

void DrawElements(PP_Resource context_id,
                  GLenum mode,
                  GLsizei count,
                  GLenum type,
                  const void* indices) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glDrawElements(mode, count, type, indices);
  }
}

void Enable(PP_Resource context_id, GLenum cap) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glEnable(cap);
  }
}

void EnableVertexAttribArray(PP_Resource context_id, GLuint index) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glEnableVertexAttribArray(index);
  }
}

void Finish(PP_Resource context_id) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glFinish();
  }
}

void Flush(PP_Resource context_id) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glFlush();
  }
}

void FramebufferRenderbuffer(PP_Resource context_id,
                             GLenum target,
                             GLenum attachment,
                             GLenum renderbuffertarget,
                             GLuint renderbuffer) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glFramebufferRenderbuffer(
        target, attachment, renderbuffertarget, renderbuffer);
  }
}

void FramebufferTexture2D(PP_Resource context_id,
                          GLenum target,
                          GLenum attachment,
                          GLenum textarget,
                          GLuint texture,
                          GLint level) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glFramebufferTexture2D(target, attachment, textarget, texture, level);
  }
}

void FrontFace(PP_Resource context_id, GLenum mode) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glFrontFace(mode);
  }
}

void GenBuffers(PP_Resource context_id, GLsizei n, GLuint* buffers) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGenBuffers(n, buffers);
  }
}

void GenerateMipmap(PP_Resource context_id, GLenum target) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGenerateMipmap(target);
  }
}

void GenFramebuffers(PP_Resource context_id, GLsizei n, GLuint* framebuffers) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGenFramebuffers(n, framebuffers);
  }
}

void GenRenderbuffers(PP_Resource context_id,
                      GLsizei n,
                      GLuint* renderbuffers) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGenRenderbuffers(n, renderbuffers);
  }
}

void GenTextures(PP_Resource context_id, GLsizei n, GLuint* textures) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGenTextures(n, textures);
  }
}

void GetActiveAttrib(PP_Resource context_id,
                     GLuint program,
                     GLuint index,
                     GLsizei bufsize,
                     GLsizei* length,
                     GLint* size,
                     GLenum* type,
                     char* name) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetActiveAttrib(program, index, bufsize, length, size, type, name);
  }
}

void GetActiveUniform(PP_Resource context_id,
                      GLuint program,
                      GLuint index,
                      GLsizei bufsize,
                      GLsizei* length,
                      GLint* size,
                      GLenum* type,
                      char* name) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetActiveUniform(program, index, bufsize, length, size, type, name);
  }
}

void GetAttachedShaders(PP_Resource context_id,
                        GLuint program,
                        GLsizei maxcount,
                        GLsizei* count,
                        GLuint* shaders) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetAttachedShaders(program, maxcount, count, shaders);
  }
}

GLint GetAttribLocation(PP_Resource context_id,
                        GLuint program,
                        const char* name) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glGetAttribLocation(program, name);
  } else {
    return -1;
  }
}

void GetBooleanv(PP_Resource context_id, GLenum pname, GLboolean* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetBooleanv(pname, params);
  }
}

void GetBufferParameteriv(PP_Resource context_id,
                          GLenum target,
                          GLenum pname,
                          GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetBufferParameteriv(target, pname, params);
  }
}

GLenum GetError(PP_Resource context_id) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glGetError();
  } else {
    return 0;
  }
}

void GetFloatv(PP_Resource context_id, GLenum pname, GLfloat* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetFloatv(pname, params);
  }
}

void GetFramebufferAttachmentParameteriv(PP_Resource context_id,
                                         GLenum target,
                                         GLenum attachment,
                                         GLenum pname,
                                         GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
  }
}

void GetIntegerv(PP_Resource context_id, GLenum pname, GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetIntegerv(pname, params);
  }
}

void GetProgramiv(PP_Resource context_id,
                  GLuint program,
                  GLenum pname,
                  GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetProgramiv(program, pname, params);
  }
}

void GetProgramInfoLog(PP_Resource context_id,
                       GLuint program,
                       GLsizei bufsize,
                       GLsizei* length,
                       char* infolog) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetProgramInfoLog(program, bufsize, length, infolog);
  }
}

void GetRenderbufferParameteriv(PP_Resource context_id,
                                GLenum target,
                                GLenum pname,
                                GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetRenderbufferParameteriv(target, pname, params);
  }
}

void GetShaderiv(PP_Resource context_id,
                 GLuint shader,
                 GLenum pname,
                 GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetShaderiv(shader, pname, params);
  }
}

void GetShaderInfoLog(PP_Resource context_id,
                      GLuint shader,
                      GLsizei bufsize,
                      GLsizei* length,
                      char* infolog) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetShaderInfoLog(shader, bufsize, length, infolog);
  }
}

void GetShaderPrecisionFormat(PP_Resource context_id,
                              GLenum shadertype,
                              GLenum precisiontype,
                              GLint* range,
                              GLint* precision) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
  }
}

void GetShaderSource(PP_Resource context_id,
                     GLuint shader,
                     GLsizei bufsize,
                     GLsizei* length,
                     char* source) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetShaderSource(shader, bufsize, length, source);
  }
}

const GLubyte* GetString(PP_Resource context_id, GLenum name) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glGetString(name);
  } else {
    return NULL;
  }
}

void GetTexParameterfv(PP_Resource context_id,
                       GLenum target,
                       GLenum pname,
                       GLfloat* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetTexParameterfv(target, pname, params);
  }
}

void GetTexParameteriv(PP_Resource context_id,
                       GLenum target,
                       GLenum pname,
                       GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetTexParameteriv(target, pname, params);
  }
}

void GetUniformfv(PP_Resource context_id,
                  GLuint program,
                  GLint location,
                  GLfloat* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetUniformfv(program, location, params);
  }
}

void GetUniformiv(PP_Resource context_id,
                  GLuint program,
                  GLint location,
                  GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetUniformiv(program, location, params);
  }
}

GLint GetUniformLocation(PP_Resource context_id,
                         GLuint program,
                         const char* name) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glGetUniformLocation(program, name);
  } else {
    return -1;
  }
}

void GetVertexAttribfv(PP_Resource context_id,
                       GLuint index,
                       GLenum pname,
                       GLfloat* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetVertexAttribfv(index, pname, params);
  }
}

void GetVertexAttribiv(PP_Resource context_id,
                       GLuint index,
                       GLenum pname,
                       GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetVertexAttribiv(index, pname, params);
  }
}

void GetVertexAttribPointerv(PP_Resource context_id,
                             GLuint index,
                             GLenum pname,
                             void** pointer) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glGetVertexAttribPointerv(index, pname, pointer);
  }
}

void Hint(PP_Resource context_id, GLenum target, GLenum mode) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glHint(target, mode);
  }
}

GLboolean IsBuffer(PP_Resource context_id, GLuint buffer) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glIsBuffer(buffer);
  } else {
    return GL_FALSE;
  }
}

GLboolean IsEnabled(PP_Resource context_id, GLenum cap) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glIsEnabled(cap);
  } else {
    return GL_FALSE;
  }
}

GLboolean IsFramebuffer(PP_Resource context_id, GLuint framebuffer) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glIsFramebuffer(framebuffer);
  } else {
    return GL_FALSE;
  }
}

GLboolean IsProgram(PP_Resource context_id, GLuint program) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glIsProgram(program);
  } else {
    return GL_FALSE;
  }
}

GLboolean IsRenderbuffer(PP_Resource context_id, GLuint renderbuffer) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glIsRenderbuffer(renderbuffer);
  } else {
    return GL_FALSE;
  }
}

GLboolean IsShader(PP_Resource context_id, GLuint shader) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glIsShader(shader);
  } else {
    return GL_FALSE;
  }
}

GLboolean IsTexture(PP_Resource context_id, GLuint texture) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    return glIsTexture(texture);
  } else {
    return GL_FALSE;
  }
}

void LineWidth(PP_Resource context_id, GLfloat width) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glLineWidth(width);
  }
}

void LinkProgram(PP_Resource context_id, GLuint program) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glLinkProgram(program);
  }
}

void PixelStorei(PP_Resource context_id, GLenum pname, GLint param) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glPixelStorei(pname, param);
  }
}

void PolygonOffset(PP_Resource context_id, GLfloat factor, GLfloat units) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glPolygonOffset(factor, units);
  }
}

void ReadPixels(PP_Resource context_id,
                GLint x,
                GLint y,
                GLsizei width,
                GLsizei height,
                GLenum format,
                GLenum type,
                void* pixels) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glReadPixels(x, y, width, height, format, type, pixels);
  }
}

void ReleaseShaderCompiler(PP_Resource context_id) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glReleaseShaderCompiler();
  }
}

void RenderbufferStorage(PP_Resource context_id,
                         GLenum target,
                         GLenum internalformat,
                         GLsizei width,
                         GLsizei height) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glRenderbufferStorage(target, internalformat, width, height);
  }
}

void SampleCoverage(PP_Resource context_id, GLclampf value, GLboolean invert) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glSampleCoverage(value, invert);
  }
}

void Scissor(PP_Resource context_id,
             GLint x,
             GLint y,
             GLsizei width,
             GLsizei height) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glScissor(x, y, width, height);
  }
}

void ShaderBinary(PP_Resource context_id,
                  GLsizei n,
                  const GLuint* shaders,
                  GLenum binaryformat,
                  const void* binary,
                  GLsizei length) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glShaderBinary(n, shaders, binaryformat, binary, length);
  }
}

void ShaderSource(PP_Resource context_id,
                  GLuint shader,
                  GLsizei count,
                  const char** str,
                  const GLint* length) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glShaderSource(shader, count, str, length);
  }
}

void StencilFunc(PP_Resource context_id, GLenum func, GLint ref, GLuint mask) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glStencilFunc(func, ref, mask);
  }
}

void StencilFuncSeparate(PP_Resource context_id,
                         GLenum face,
                         GLenum func,
                         GLint ref,
                         GLuint mask) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glStencilFuncSeparate(face, func, ref, mask);
  }
}

void StencilMask(PP_Resource context_id, GLuint mask) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glStencilMask(mask);
  }
}

void StencilMaskSeparate(PP_Resource context_id, GLenum face, GLuint mask) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glStencilMaskSeparate(face, mask);
  }
}

void StencilOp(PP_Resource context_id,
               GLenum fail,
               GLenum zfail,
               GLenum zpass) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glStencilOp(fail, zfail, zpass);
  }
}

void StencilOpSeparate(PP_Resource context_id,
                       GLenum face,
                       GLenum fail,
                       GLenum zfail,
                       GLenum zpass) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glStencilOpSeparate(face, fail, zfail, zpass);
  }
}

void TexImage2D(PP_Resource context_id,
                GLenum target,
                GLint level,
                GLint internalformat,
                GLsizei width,
                GLsizei height,
                GLint border,
                GLenum format,
                GLenum type,
                const void* pixels) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glTexImage2D(target,
                 level,
                 internalformat,
                 width,
                 height,
                 border,
                 format,
                 type,
                 pixels);
  }
}

void TexParameterf(PP_Resource context_id,
                   GLenum target,
                   GLenum pname,
                   GLfloat param) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glTexParameterf(target, pname, param);
  }
}

void TexParameterfv(PP_Resource context_id,
                    GLenum target,
                    GLenum pname,
                    const GLfloat* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glTexParameterfv(target, pname, params);
  }
}

void TexParameteri(PP_Resource context_id,
                   GLenum target,
                   GLenum pname,
                   GLint param) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glTexParameteri(target, pname, param);
  }
}

void TexParameteriv(PP_Resource context_id,
                    GLenum target,
                    GLenum pname,
                    const GLint* params) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glTexParameteriv(target, pname, params);
  }
}

void TexSubImage2D(PP_Resource context_id,
                   GLenum target,
                   GLint level,
                   GLint xoffset,
                   GLint yoffset,
                   GLsizei width,
                   GLsizei height,
                   GLenum format,
                   GLenum type,
                   const void* pixels) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glTexSubImage2D(
        target, level, xoffset, yoffset, width, height, format, type, pixels);
  }
}

void Uniform1f(PP_Resource context_id, GLint location, GLfloat x) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform1f(location, x);
  }
}

void Uniform1fv(PP_Resource context_id,
                GLint location,
                GLsizei count,
                const GLfloat* v) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform1fv(location, count, v);
  }
}

void Uniform1i(PP_Resource context_id, GLint location, GLint x) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform1i(location, x);
  }
}

void Uniform1iv(PP_Resource context_id,
                GLint location,
                GLsizei count,
                const GLint* v) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform1iv(location, count, v);
  }
}

void Uniform2f(PP_Resource context_id, GLint location, GLfloat x, GLfloat y) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform2f(location, x, y);
  }
}

void Uniform2fv(PP_Resource context_id,
                GLint location,
                GLsizei count,
                const GLfloat* v) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform2fv(location, count, v);
  }
}

void Uniform2i(PP_Resource context_id, GLint location, GLint x, GLint y) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform2i(location, x, y);
  }
}

void Uniform2iv(PP_Resource context_id,
                GLint location,
                GLsizei count,
                const GLint* v) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform2iv(location, count, v);
  }
}

void Uniform3f(PP_Resource context_id,
               GLint location,
               GLfloat x,
               GLfloat y,
               GLfloat z) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform3f(location, x, y, z);
  }
}

void Uniform3fv(PP_Resource context_id,
                GLint location,
                GLsizei count,
                const GLfloat* v) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform3fv(location, count, v);
  }
}

void Uniform3i(PP_Resource context_id,
               GLint location,
               GLint x,
               GLint y,
               GLint z) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform3i(location, x, y, z);
  }
}

void Uniform3iv(PP_Resource context_id,
                GLint location,
                GLsizei count,
                const GLint* v) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform3iv(location, count, v);
  }
}

void Uniform4f(PP_Resource context_id,
               GLint location,
               GLfloat x,
               GLfloat y,
               GLfloat z,
               GLfloat w) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform4f(location, x, y, z, w);
  }
}

void Uniform4fv(PP_Resource context_id,
                GLint location,
                GLsizei count,
                const GLfloat* v) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform4fv(location, count, v);
  }
}

void Uniform4i(PP_Resource context_id,
               GLint location,
               GLint x,
               GLint y,
               GLint z,
               GLint w) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform4i(location, x, y, z, w);
  }
}

void Uniform4iv(PP_Resource context_id,
                GLint location,
                GLsizei count,
                const GLint* v) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniform4iv(location, count, v);
  }
}

void UniformMatrix2fv(PP_Resource context_id,
                      GLint location,
                      GLsizei count,
                      GLboolean transpose,
                      const GLfloat* value) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniformMatrix2fv(location, count, transpose, value);
  }
}

void UniformMatrix3fv(PP_Resource context_id,
                      GLint location,
                      GLsizei count,
                      GLboolean transpose,
                      const GLfloat* value) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniformMatrix3fv(location, count, transpose, value);
  }
}

void UniformMatrix4fv(PP_Resource context_id,
                      GLint location,
                      GLsizei count,
                      GLboolean transpose,
                      const GLfloat* value) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUniformMatrix4fv(location, count, transpose, value);
  }
}

void UseProgram(PP_Resource context_id, GLuint program) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glUseProgram(program);
  }
}

void ValidateProgram(PP_Resource context_id, GLuint program) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glValidateProgram(program);
  }
}

void VertexAttrib1f(PP_Resource context_id, GLuint indx, GLfloat x) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttrib1f(indx, x);
  }
}

void VertexAttrib1fv(PP_Resource context_id,
                     GLuint indx,
                     const GLfloat* values) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttrib1fv(indx, values);
  }
}

void VertexAttrib2f(PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttrib2f(indx, x, y);
  }
}

void VertexAttrib2fv(PP_Resource context_id,
                     GLuint indx,
                     const GLfloat* values) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttrib2fv(indx, values);
  }
}

void VertexAttrib3f(PP_Resource context_id,
                    GLuint indx,
                    GLfloat x,
                    GLfloat y,
                    GLfloat z) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttrib3f(indx, x, y, z);
  }
}

void VertexAttrib3fv(PP_Resource context_id,
                     GLuint indx,
                     const GLfloat* values) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttrib3fv(indx, values);
  }
}

void VertexAttrib4f(PP_Resource context_id,
                    GLuint indx,
                    GLfloat x,
                    GLfloat y,
                    GLfloat z,
                    GLfloat w) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttrib4f(indx, x, y, z, w);
  }
}

void VertexAttrib4fv(PP_Resource context_id,
                     GLuint indx,
                     const GLfloat* values) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttrib4fv(indx, values);
  }
}

void VertexAttribPointer(PP_Resource context_id,
                         GLuint indx,
                         GLint size,
                         GLenum type,
                         GLboolean normalized,
                         GLsizei stride,
                         const void* ptr) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
  }
}

void Viewport(PP_Resource context_id,
              GLint x,
              GLint y,
              GLsizei width,
              GLsizei height) {
  Enter3D enter(context_id, true);
  if (IsBoundGraphics(&enter)) {
    glViewport(x, y, width, height);
  }
}

}  // namespace

const PPB_OpenGLES2* GetPPB_OpenGLES2_Thunk() {
  static const struct PPB_OpenGLES2 ppb_opengles2 = {
      &ActiveTexture,                       &AttachShader,
      &BindAttribLocation,                  &BindBuffer,
      &BindFramebuffer,                     &BindRenderbuffer,
      &BindTexture,                         &BlendColor,
      &BlendEquation,                       &BlendEquationSeparate,
      &BlendFunc,                           &BlendFuncSeparate,
      &BufferData,                          &BufferSubData,
      &CheckFramebufferStatus,              &Clear,
      &ClearColor,                          &ClearDepthf,
      &ClearStencil,                        &ColorMask,
      &CompileShader,                       &CompressedTexImage2D,
      &CompressedTexSubImage2D,             &CopyTexImage2D,
      &CopyTexSubImage2D,                   &CreateProgram,
      &CreateShader,                        &CullFace,
      &DeleteBuffers,                       &DeleteFramebuffers,
      &DeleteProgram,                       &DeleteRenderbuffers,
      &DeleteShader,                        &DeleteTextures,
      &DepthFunc,                           &DepthMask,
      &DepthRangef,                         &DetachShader,
      &Disable,                             &DisableVertexAttribArray,
      &DrawArrays,                          &DrawElements,
      &Enable,                              &EnableVertexAttribArray,
      &Finish,                              &Flush,
      &FramebufferRenderbuffer,             &FramebufferTexture2D,
      &FrontFace,                           &GenBuffers,
      &GenerateMipmap,                      &GenFramebuffers,
      &GenRenderbuffers,                    &GenTextures,
      &GetActiveAttrib,                     &GetActiveUniform,
      &GetAttachedShaders,                  &GetAttribLocation,
      &GetBooleanv,                         &GetBufferParameteriv,
      &GetError,                            &GetFloatv,
      &GetFramebufferAttachmentParameteriv, &GetIntegerv,
      &GetProgramiv,                        &GetProgramInfoLog,
      &GetRenderbufferParameteriv,          &GetShaderiv,
      &GetShaderInfoLog,                    &GetShaderPrecisionFormat,
      &GetShaderSource,                     &GetString,
      &GetTexParameterfv,                   &GetTexParameteriv,
      &GetUniformfv,                        &GetUniformiv,
      &GetUniformLocation,                  &GetVertexAttribfv,
      &GetVertexAttribiv,                   &GetVertexAttribPointerv,
      &Hint,                                &IsBuffer,
      &IsEnabled,                           &IsFramebuffer,
      &IsProgram,                           &IsRenderbuffer,
      &IsShader,                            &IsTexture,
      &LineWidth,                           &LinkProgram,
      &PixelStorei,                         &PolygonOffset,
      &ReadPixels,                          &ReleaseShaderCompiler,
      &RenderbufferStorage,                 &SampleCoverage,
      &Scissor,                             &ShaderBinary,
      &ShaderSource,                        &StencilFunc,
      &StencilFuncSeparate,                 &StencilMask,
      &StencilMaskSeparate,                 &StencilOp,
      &StencilOpSeparate,                   &TexImage2D,
      &TexParameterf,                       &TexParameterfv,
      &TexParameteri,                       &TexParameteriv,
      &TexSubImage2D,                       &Uniform1f,
      &Uniform1fv,                          &Uniform1i,
      &Uniform1iv,                          &Uniform2f,
      &Uniform2fv,                          &Uniform2i,
      &Uniform2iv,                          &Uniform3f,
      &Uniform3fv,                          &Uniform3i,
      &Uniform3iv,                          &Uniform4f,
      &Uniform4fv,                          &Uniform4i,
      &Uniform4iv,                          &UniformMatrix2fv,
      &UniformMatrix3fv,                    &UniformMatrix4fv,
      &UseProgram,                          &ValidateProgram,
      &VertexAttrib1f,                      &VertexAttrib1fv,
      &VertexAttrib2f,                      &VertexAttrib2fv,
      &VertexAttrib3f,                      &VertexAttrib3fv,
      &VertexAttrib4f,                      &VertexAttrib4fv,
      &VertexAttribPointer,                 &Viewport};
  return &ppb_opengles2;
}

}  // namespace examples
}  // namespace mojo
/* [<][>][^][v][top][bottom][index][help] */