text: // 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.
  
  // 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!
  
  #include "mojo/gpu/mojo_gles2_impl_autogen.h"
  
  #include "base/logging.h"
  #include "mojo/public/c/gles2/chromium_extension.h"
  #include "mojo/public/c/gles2/gles2.h"
  
  namespace mojo {
  
  void MojoGLES2Impl::ActiveTexture(GLenum texture) {
    MojoGLES2MakeCurrent(context_);
    glActiveTexture(texture);
  }
  void MojoGLES2Impl::AttachShader(GLuint program, GLuint shader) {
    MojoGLES2MakeCurrent(context_);
    glAttachShader(program, shader);
  }
  void MojoGLES2Impl::BindAttribLocation(GLuint program,
                                         GLuint index,
                                         const char* name) {
    MojoGLES2MakeCurrent(context_);
    glBindAttribLocation(program, index, name);
  }
  void MojoGLES2Impl::BindBuffer(GLenum target, GLuint buffer) {
    MojoGLES2MakeCurrent(context_);
    glBindBuffer(target, buffer);
  }
  void MojoGLES2Impl::BindBufferBase(GLenum target, GLuint index, GLuint buffer) {
    NOTREACHED() << "Unimplemented BindBufferBase.";
  }
  void MojoGLES2Impl::BindBufferRange(GLenum target,
                                      GLuint index,
                                      GLuint buffer,
                                      GLintptr offset,
                                      GLsizeiptr size) {
    NOTREACHED() << "Unimplemented BindBufferRange.";
  }
  void MojoGLES2Impl::BindFramebuffer(GLenum target, GLuint framebuffer) {
    MojoGLES2MakeCurrent(context_);
    glBindFramebuffer(target, framebuffer);
  }
  void MojoGLES2Impl::BindRenderbuffer(GLenum target, GLuint renderbuffer) {
    MojoGLES2MakeCurrent(context_);
    glBindRenderbuffer(target, renderbuffer);
  }
  void MojoGLES2Impl::BindSampler(GLuint unit, GLuint sampler) {
    NOTREACHED() << "Unimplemented BindSampler.";
  }
  void MojoGLES2Impl::BindTexture(GLenum target, GLuint texture) {
    MojoGLES2MakeCurrent(context_);
    glBindTexture(target, texture);
  }
  void MojoGLES2Impl::BindTransformFeedback(GLenum target,
                                            GLuint transformfeedback) {
    NOTREACHED() << "Unimplemented BindTransformFeedback.";
  }
  void MojoGLES2Impl::BlendColor(GLclampf red,
                                 GLclampf green,
                                 GLclampf blue,
                                 GLclampf alpha) {
    MojoGLES2MakeCurrent(context_);
    glBlendColor(red, green, blue, alpha);
  }
  void MojoGLES2Impl::BlendEquation(GLenum mode) {
    MojoGLES2MakeCurrent(context_);
    glBlendEquation(mode);
  }
  void MojoGLES2Impl::BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
    MojoGLES2MakeCurrent(context_);
    glBlendEquationSeparate(modeRGB, modeAlpha);
  }
  void MojoGLES2Impl::BlendFunc(GLenum sfactor, GLenum dfactor) {
    MojoGLES2MakeCurrent(context_);
    glBlendFunc(sfactor, dfactor);
  }
  void MojoGLES2Impl::BlendFuncSeparate(GLenum srcRGB,
                                        GLenum dstRGB,
                                        GLenum srcAlpha,
                                        GLenum dstAlpha) {
    MojoGLES2MakeCurrent(context_);
    glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
  }
  void MojoGLES2Impl::BufferData(GLenum target,
                                 GLsizeiptr size,
                                 const void* data,
                                 GLenum usage) {
    MojoGLES2MakeCurrent(context_);
    glBufferData(target, size, data, usage);
  }
  void MojoGLES2Impl::BufferSubData(GLenum target,
                                    GLintptr offset,
                                    GLsizeiptr size,
                                    const void* data) {
    MojoGLES2MakeCurrent(context_);
    glBufferSubData(target, offset, size, data);
  }
  GLenum MojoGLES2Impl::CheckFramebufferStatus(GLenum target) {
    MojoGLES2MakeCurrent(context_);
    return glCheckFramebufferStatus(target);
  }
  void MojoGLES2Impl::Clear(GLbitfield mask) {
    MojoGLES2MakeCurrent(context_);
    glClear(mask);
  }
  void MojoGLES2Impl::ClearBufferfi(GLenum buffer,
                                    GLint drawbuffers,
                                    GLfloat depth,
                                    GLint stencil) {
    NOTREACHED() << "Unimplemented ClearBufferfi.";
  }
  void MojoGLES2Impl::ClearBufferfv(GLenum buffer,
                                    GLint drawbuffers,
                                    const GLfloat* value) {
    NOTREACHED() << "Unimplemented ClearBufferfv.";
  }
  void MojoGLES2Impl::ClearBufferiv(GLenum buffer,
                                    GLint drawbuffers,
                                    const GLint* value) {
    NOTREACHED() << "Unimplemented ClearBufferiv.";
  }
  void MojoGLES2Impl::ClearBufferuiv(GLenum buffer,
                                     GLint drawbuffers,
                                     const GLuint* value) {
    NOTREACHED() << "Unimplemented ClearBufferuiv.";
  }
  void MojoGLES2Impl::ClearColor(GLclampf red,
                                 GLclampf green,
                                 GLclampf blue,
                                 GLclampf alpha) {
    MojoGLES2MakeCurrent(context_);
    glClearColor(red, green, blue, alpha);
  }
  void MojoGLES2Impl::ClearDepthf(GLclampf depth) {
    MojoGLES2MakeCurrent(context_);
    glClearDepthf(depth);
  }
  void MojoGLES2Impl::ClearStencil(GLint s) {
    MojoGLES2MakeCurrent(context_);
    glClearStencil(s);
  }
  GLenum MojoGLES2Impl::ClientWaitSync(GLsync sync,
                                       GLbitfield flags,
                                       GLuint64 timeout) {
    NOTREACHED() << "Unimplemented ClientWaitSync.";
    return 0;
  }
  void MojoGLES2Impl::ColorMask(GLboolean red,
                                GLboolean green,
                                GLboolean blue,
                                GLboolean alpha) {
    MojoGLES2MakeCurrent(context_);
    glColorMask(red, green, blue, alpha);
  }
  void MojoGLES2Impl::CompileShader(GLuint shader) {
    MojoGLES2MakeCurrent(context_);
    glCompileShader(shader);
  }
  void MojoGLES2Impl::CompressedTexImage2D(GLenum target,
                                           GLint level,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLint border,
                                           GLsizei imageSize,
                                           const void* data) {
    MojoGLES2MakeCurrent(context_);
    glCompressedTexImage2D(target, level, internalformat, width, height, border,
                           imageSize, data);
  }
  void MojoGLES2Impl::CompressedTexSubImage2D(GLenum target,
                                              GLint level,
                                              GLint xoffset,
                                              GLint yoffset,
                                              GLsizei width,
                                              GLsizei height,
                                              GLenum format,
                                              GLsizei imageSize,
                                              const void* data) {
    MojoGLES2MakeCurrent(context_);
    glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
                              format, imageSize, data);
  }
  void MojoGLES2Impl::CompressedTexImage3D(GLenum target,
                                           GLint level,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLsizei depth,
                                           GLint border,
                                           GLsizei imageSize,
                                           const void* data) {
    NOTREACHED() << "Unimplemented CompressedTexImage3D.";
  }
  void MojoGLES2Impl::CompressedTexSubImage3D(GLenum target,
                                              GLint level,
                                              GLint xoffset,
                                              GLint yoffset,
                                              GLint zoffset,
                                              GLsizei width,
                                              GLsizei height,
                                              GLsizei depth,
                                              GLenum format,
                                              GLsizei imageSize,
                                              const void* data) {
    NOTREACHED() << "Unimplemented CompressedTexSubImage3D.";
  }
  void MojoGLES2Impl::CopyBufferSubData(GLenum readtarget,
                                        GLenum writetarget,
                                        GLintptr readoffset,
                                        GLintptr writeoffset,
                                        GLsizeiptr size) {
    NOTREACHED() << "Unimplemented CopyBufferSubData.";
  }
  void MojoGLES2Impl::CopyTexImage2D(GLenum target,
                                     GLint level,
                                     GLenum internalformat,
                                     GLint x,
                                     GLint y,
                                     GLsizei width,
                                     GLsizei height,
                                     GLint border) {
    MojoGLES2MakeCurrent(context_);
    glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
  }
  void MojoGLES2Impl::CopyTexSubImage2D(GLenum target,
                                        GLint level,
                                        GLint xoffset,
                                        GLint yoffset,
                                        GLint x,
                                        GLint y,
                                        GLsizei width,
                                        GLsizei height) {
    MojoGLES2MakeCurrent(context_);
    glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
  }
  void MojoGLES2Impl::CopyTexSubImage3D(GLenum target,
                                        GLint level,
                                        GLint xoffset,
                                        GLint yoffset,
                                        GLint zoffset,
                                        GLint x,
                                        GLint y,
                                        GLsizei width,
                                        GLsizei height) {
    NOTREACHED() << "Unimplemented CopyTexSubImage3D.";
  }
  GLuint MojoGLES2Impl::CreateProgram() {
    MojoGLES2MakeCurrent(context_);
    return glCreateProgram();
  }
  GLuint MojoGLES2Impl::CreateShader(GLenum type) {
    MojoGLES2MakeCurrent(context_);
    return glCreateShader(type);
  }
  void MojoGLES2Impl::CullFace(GLenum mode) {
    MojoGLES2MakeCurrent(context_);
    glCullFace(mode);
  }
  void MojoGLES2Impl::DeleteBuffers(GLsizei n, const GLuint* buffers) {
    MojoGLES2MakeCurrent(context_);
    glDeleteBuffers(n, buffers);
  }
  void MojoGLES2Impl::DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
    MojoGLES2MakeCurrent(context_);
    glDeleteFramebuffers(n, framebuffers);
  }
  void MojoGLES2Impl::DeleteProgram(GLuint program) {
    MojoGLES2MakeCurrent(context_);
    glDeleteProgram(program);
  }
  void MojoGLES2Impl::DeleteRenderbuffers(GLsizei n,
                                          const GLuint* renderbuffers) {
    MojoGLES2MakeCurrent(context_);
    glDeleteRenderbuffers(n, renderbuffers);
  }
  void MojoGLES2Impl::DeleteSamplers(GLsizei n, const GLuint* samplers) {
    NOTREACHED() << "Unimplemented DeleteSamplers.";
  }
  void MojoGLES2Impl::DeleteSync(GLsync sync) {
    NOTREACHED() << "Unimplemented DeleteSync.";
  }
  void MojoGLES2Impl::DeleteShader(GLuint shader) {
    MojoGLES2MakeCurrent(context_);
    glDeleteShader(shader);
  }
  void MojoGLES2Impl::DeleteTextures(GLsizei n, const GLuint* textures) {
    MojoGLES2MakeCurrent(context_);
    glDeleteTextures(n, textures);
  }
  void MojoGLES2Impl::DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
    NOTREACHED() << "Unimplemented DeleteTransformFeedbacks.";
  }
  void MojoGLES2Impl::DepthFunc(GLenum func) {
    MojoGLES2MakeCurrent(context_);
    glDepthFunc(func);
  }
  void MojoGLES2Impl::DepthMask(GLboolean flag) {
    MojoGLES2MakeCurrent(context_);
    glDepthMask(flag);
  }
  void MojoGLES2Impl::DepthRangef(GLclampf zNear, GLclampf zFar) {
    MojoGLES2MakeCurrent(context_);
    glDepthRangef(zNear, zFar);
  }
  void MojoGLES2Impl::DetachShader(GLuint program, GLuint shader) {
    MojoGLES2MakeCurrent(context_);
    glDetachShader(program, shader);
  }
  void MojoGLES2Impl::Disable(GLenum cap) {
    MojoGLES2MakeCurrent(context_);
    glDisable(cap);
  }
  void MojoGLES2Impl::DisableVertexAttribArray(GLuint index) {
    MojoGLES2MakeCurrent(context_);
    glDisableVertexAttribArray(index);
  }
  void MojoGLES2Impl::DrawArrays(GLenum mode, GLint first, GLsizei count) {
    MojoGLES2MakeCurrent(context_);
    glDrawArrays(mode, first, count);
  }
  void MojoGLES2Impl::DrawElements(GLenum mode,
                                   GLsizei count,
                                   GLenum type,
                                   const void* indices) {
    MojoGLES2MakeCurrent(context_);
    glDrawElements(mode, count, type, indices);
  }
  void MojoGLES2Impl::DrawRangeElements(GLenum mode,
                                        GLuint start,
                                        GLuint end,
                                        GLsizei count,
                                        GLenum type,
                                        const void* indices) {
    NOTREACHED() << "Unimplemented DrawRangeElements.";
  }
  void MojoGLES2Impl::Enable(GLenum cap) {
    MojoGLES2MakeCurrent(context_);
    glEnable(cap);
  }
  void MojoGLES2Impl::EnableVertexAttribArray(GLuint index) {
    MojoGLES2MakeCurrent(context_);
    glEnableVertexAttribArray(index);
  }
  GLsync MojoGLES2Impl::FenceSync(GLenum condition, GLbitfield flags) {
    NOTREACHED() << "Unimplemented FenceSync.";
    return 0;
  }
  void MojoGLES2Impl::Finish() {
    MojoGLES2MakeCurrent(context_);
    glFinish();
  }
  void MojoGLES2Impl::Flush() {
    MojoGLES2MakeCurrent(context_);
    glFlush();
  }
  void MojoGLES2Impl::FramebufferRenderbuffer(GLenum target,
                                              GLenum attachment,
                                              GLenum renderbuffertarget,
                                              GLuint renderbuffer) {
    MojoGLES2MakeCurrent(context_);
    glFramebufferRenderbuffer(target, attachment, renderbuffertarget,
                              renderbuffer);
  }
  void MojoGLES2Impl::FramebufferTexture2D(GLenum target,
                                           GLenum attachment,
                                           GLenum textarget,
                                           GLuint texture,
                                           GLint level) {
    MojoGLES2MakeCurrent(context_);
    glFramebufferTexture2D(target, attachment, textarget, texture, level);
  }
  void MojoGLES2Impl::FramebufferTextureLayer(GLenum target,
                                              GLenum attachment,
                                              GLuint texture,
                                              GLint level,
                                              GLint layer) {
    NOTREACHED() << "Unimplemented FramebufferTextureLayer.";
  }
  void MojoGLES2Impl::FrontFace(GLenum mode) {
    MojoGLES2MakeCurrent(context_);
    glFrontFace(mode);
  }
  void MojoGLES2Impl::GenBuffers(GLsizei n, GLuint* buffers) {
    MojoGLES2MakeCurrent(context_);
    glGenBuffers(n, buffers);
  }
  void MojoGLES2Impl::GenerateMipmap(GLenum target) {
    MojoGLES2MakeCurrent(context_);
    glGenerateMipmap(target);
  }
  void MojoGLES2Impl::GenFramebuffers(GLsizei n, GLuint* framebuffers) {
    MojoGLES2MakeCurrent(context_);
    glGenFramebuffers(n, framebuffers);
  }
  void MojoGLES2Impl::GenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
    MojoGLES2MakeCurrent(context_);
    glGenRenderbuffers(n, renderbuffers);
  }
  void MojoGLES2Impl::GenSamplers(GLsizei n, GLuint* samplers) {
    NOTREACHED() << "Unimplemented GenSamplers.";
  }
  void MojoGLES2Impl::GenTextures(GLsizei n, GLuint* textures) {
    MojoGLES2MakeCurrent(context_);
    glGenTextures(n, textures);
  }
  void MojoGLES2Impl::GenTransformFeedbacks(GLsizei n, GLuint* ids) {
    NOTREACHED() << "Unimplemented GenTransformFeedbacks.";
  }
  void MojoGLES2Impl::GetActiveAttrib(GLuint program,
                                      GLuint index,
                                      GLsizei bufsize,
                                      GLsizei* length,
                                      GLint* size,
                                      GLenum* type,
                                      char* name) {
    MojoGLES2MakeCurrent(context_);
    glGetActiveAttrib(program, index, bufsize, length, size, type, name);
  }
  void MojoGLES2Impl::GetActiveUniform(GLuint program,
                                       GLuint index,
                                       GLsizei bufsize,
                                       GLsizei* length,
                                       GLint* size,
                                       GLenum* type,
                                       char* name) {
    MojoGLES2MakeCurrent(context_);
    glGetActiveUniform(program, index, bufsize, length, size, type, name);
  }
  void MojoGLES2Impl::GetActiveUniformBlockiv(GLuint program,
                                              GLuint index,
                                              GLenum pname,
                                              GLint* params) {
    NOTREACHED() << "Unimplemented GetActiveUniformBlockiv.";
  }
  void MojoGLES2Impl::GetActiveUniformBlockName(GLuint program,
                                                GLuint index,
                                                GLsizei bufsize,
                                                GLsizei* length,
                                                char* name) {
    NOTREACHED() << "Unimplemented GetActiveUniformBlockName.";
  }
  void MojoGLES2Impl::GetActiveUniformsiv(GLuint program,
                                          GLsizei count,
                                          const GLuint* indices,
                                          GLenum pname,
                                          GLint* params) {
    NOTREACHED() << "Unimplemented GetActiveUniformsiv.";
  }
  void MojoGLES2Impl::GetAttachedShaders(GLuint program,
                                         GLsizei maxcount,
                                         GLsizei* count,
                                         GLuint* shaders) {
    MojoGLES2MakeCurrent(context_);
    glGetAttachedShaders(program, maxcount, count, shaders);
  }
  GLint MojoGLES2Impl::GetAttribLocation(GLuint program, const char* name) {
    MojoGLES2MakeCurrent(context_);
    return glGetAttribLocation(program, name);
  }
  void MojoGLES2Impl::GetBooleanv(GLenum pname, GLboolean* params) {
    MojoGLES2MakeCurrent(context_);
    glGetBooleanv(pname, params);
  }
  void MojoGLES2Impl::GetBufferParameteri64v(GLenum target,
                                             GLenum pname,
                                             GLint64* params) {
    NOTREACHED() << "Unimplemented GetBufferParameteri64v.";
  }
  void MojoGLES2Impl::GetBufferParameteriv(GLenum target,
                                           GLenum pname,
                                           GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetBufferParameteriv(target, pname, params);
  }
  GLenum MojoGLES2Impl::GetError() {
    MojoGLES2MakeCurrent(context_);
    return glGetError();
  }
  void MojoGLES2Impl::GetFloatv(GLenum pname, GLfloat* params) {
    MojoGLES2MakeCurrent(context_);
    glGetFloatv(pname, params);
  }
  GLint MojoGLES2Impl::GetFragDataLocation(GLuint program, const char* name) {
    NOTREACHED() << "Unimplemented GetFragDataLocation.";
    return 0;
  }
  void MojoGLES2Impl::GetFramebufferAttachmentParameteriv(GLenum target,
                                                          GLenum attachment,
                                                          GLenum pname,
                                                          GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
  }
  void MojoGLES2Impl::GetInteger64v(GLenum pname, GLint64* params) {
    NOTREACHED() << "Unimplemented GetInteger64v.";
  }
  void MojoGLES2Impl::GetIntegeri_v(GLenum pname, GLuint index, GLint* data) {
    NOTREACHED() << "Unimplemented GetIntegeri_v.";
  }
  void MojoGLES2Impl::GetInteger64i_v(GLenum pname, GLuint index, GLint64* data) {
    NOTREACHED() << "Unimplemented GetInteger64i_v.";
  }
  void MojoGLES2Impl::GetIntegerv(GLenum pname, GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetIntegerv(pname, params);
  }
  void MojoGLES2Impl::GetInternalformativ(GLenum target,
                                          GLenum format,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLint* params) {
    NOTREACHED() << "Unimplemented GetInternalformativ.";
  }
  void MojoGLES2Impl::GetProgramiv(GLuint program, GLenum pname, GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetProgramiv(program, pname, params);
  }
  void MojoGLES2Impl::GetProgramInfoLog(GLuint program,
                                        GLsizei bufsize,
                                        GLsizei* length,
                                        char* infolog) {
    MojoGLES2MakeCurrent(context_);
    glGetProgramInfoLog(program, bufsize, length, infolog);
  }
  void MojoGLES2Impl::GetRenderbufferParameteriv(GLenum target,
                                                 GLenum pname,
                                                 GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetRenderbufferParameteriv(target, pname, params);
  }
  void MojoGLES2Impl::GetSamplerParameterfv(GLuint sampler,
                                            GLenum pname,
                                            GLfloat* params) {
    NOTREACHED() << "Unimplemented GetSamplerParameterfv.";
  }
  void MojoGLES2Impl::GetSamplerParameteriv(GLuint sampler,
                                            GLenum pname,
                                            GLint* params) {
    NOTREACHED() << "Unimplemented GetSamplerParameteriv.";
  }
  void MojoGLES2Impl::GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetShaderiv(shader, pname, params);
  }
  void MojoGLES2Impl::GetShaderInfoLog(GLuint shader,
                                       GLsizei bufsize,
                                       GLsizei* length,
                                       char* infolog) {
    MojoGLES2MakeCurrent(context_);
    glGetShaderInfoLog(shader, bufsize, length, infolog);
  }
  void MojoGLES2Impl::GetShaderPrecisionFormat(GLenum shadertype,
                                               GLenum precisiontype,
                                               GLint* range,
                                               GLint* precision) {
    MojoGLES2MakeCurrent(context_);
    glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
  }
  void MojoGLES2Impl::GetShaderSource(GLuint shader,
                                      GLsizei bufsize,
                                      GLsizei* length,
                                      char* source) {
    MojoGLES2MakeCurrent(context_);
    glGetShaderSource(shader, bufsize, length, source);
  }
  const GLubyte* MojoGLES2Impl::GetString(GLenum name) {
    MojoGLES2MakeCurrent(context_);
    return glGetString(name);
  }
  const GLubyte* MojoGLES2Impl::GetStringi(GLenum name, GLuint index) {
    NOTREACHED() << "Unimplemented GetStringi.";
    return 0;
  }
  void MojoGLES2Impl::GetSynciv(GLsync sync,
                                GLenum pname,
                                GLsizei bufsize,
                                GLsizei* length,
                                GLint* values) {
    NOTREACHED() << "Unimplemented GetSynciv.";
  }
  void MojoGLES2Impl::GetTexParameterfv(GLenum target,
                                        GLenum pname,
                                        GLfloat* params) {
    MojoGLES2MakeCurrent(context_);
    glGetTexParameterfv(target, pname, params);
  }
  void MojoGLES2Impl::GetTexParameteriv(GLenum target,
                                        GLenum pname,
                                        GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetTexParameteriv(target, pname, params);
  }
  void MojoGLES2Impl::GetTransformFeedbackVarying(GLuint program,
                                                  GLuint index,
                                                  GLsizei bufsize,
                                                  GLsizei* length,
                                                  GLsizei* size,
                                                  GLenum* type,
                                                  char* name) {
    NOTREACHED() << "Unimplemented GetTransformFeedbackVarying.";
  }
  GLuint MojoGLES2Impl::GetUniformBlockIndex(GLuint program, const char* name) {
    NOTREACHED() << "Unimplemented GetUniformBlockIndex.";
    return 0;
  }
  void MojoGLES2Impl::GetUniformfv(GLuint program,
                                   GLint location,
                                   GLfloat* params) {
    MojoGLES2MakeCurrent(context_);
    glGetUniformfv(program, location, params);
  }
  void MojoGLES2Impl::GetUniformiv(GLuint program,
                                   GLint location,
                                   GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetUniformiv(program, location, params);
  }
  void MojoGLES2Impl::GetUniformuiv(GLuint program,
                                    GLint location,
                                    GLuint* params) {
    NOTREACHED() << "Unimplemented GetUniformuiv.";
  }
  void MojoGLES2Impl::GetUniformIndices(GLuint program,
                                        GLsizei count,
                                        const char* const* names,
                                        GLuint* indices) {
    NOTREACHED() << "Unimplemented GetUniformIndices.";
  }
  GLint MojoGLES2Impl::GetUniformLocation(GLuint program, const char* name) {
    MojoGLES2MakeCurrent(context_);
    return glGetUniformLocation(program, name);
  }
  void MojoGLES2Impl::GetVertexAttribfv(GLuint index,
                                        GLenum pname,
                                        GLfloat* params) {
    MojoGLES2MakeCurrent(context_);
    glGetVertexAttribfv(index, pname, params);
  }
  void MojoGLES2Impl::GetVertexAttribiv(GLuint index,
                                        GLenum pname,
                                        GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetVertexAttribiv(index, pname, params);
  }
  void MojoGLES2Impl::GetVertexAttribIiv(GLuint index,
                                         GLenum pname,
                                         GLint* params) {
    NOTREACHED() << "Unimplemented GetVertexAttribIiv.";
  }
  void MojoGLES2Impl::GetVertexAttribIuiv(GLuint index,
                                          GLenum pname,
                                          GLuint* params) {
    NOTREACHED() << "Unimplemented GetVertexAttribIuiv.";
  }
  void MojoGLES2Impl::GetVertexAttribPointerv(GLuint index,
                                              GLenum pname,
                                              void** pointer) {
    MojoGLES2MakeCurrent(context_);
    glGetVertexAttribPointerv(index, pname, pointer);
  }
  void MojoGLES2Impl::Hint(GLenum target, GLenum mode) {
    MojoGLES2MakeCurrent(context_);
    glHint(target, mode);
  }
  void MojoGLES2Impl::InvalidateFramebuffer(GLenum target,
                                            GLsizei count,
                                            const GLenum* attachments) {
    NOTREACHED() << "Unimplemented InvalidateFramebuffer.";
  }
  void MojoGLES2Impl::InvalidateSubFramebuffer(GLenum target,
                                               GLsizei count,
                                               const GLenum* attachments,
                                               GLint x,
                                               GLint y,
                                               GLsizei width,
                                               GLsizei height) {
    NOTREACHED() << "Unimplemented InvalidateSubFramebuffer.";
  }
  GLboolean MojoGLES2Impl::IsBuffer(GLuint buffer) {
    MojoGLES2MakeCurrent(context_);
    return glIsBuffer(buffer);
  }
  GLboolean MojoGLES2Impl::IsEnabled(GLenum cap) {
    MojoGLES2MakeCurrent(context_);
    return glIsEnabled(cap);
  }
  GLboolean MojoGLES2Impl::IsFramebuffer(GLuint framebuffer) {
    MojoGLES2MakeCurrent(context_);
    return glIsFramebuffer(framebuffer);
  }
  GLboolean MojoGLES2Impl::IsProgram(GLuint program) {
    MojoGLES2MakeCurrent(context_);
    return glIsProgram(program);
  }
  GLboolean MojoGLES2Impl::IsRenderbuffer(GLuint renderbuffer) {
    MojoGLES2MakeCurrent(context_);
    return glIsRenderbuffer(renderbuffer);
  }
  GLboolean MojoGLES2Impl::IsSampler(GLuint sampler) {
    NOTREACHED() << "Unimplemented IsSampler.";
    return 0;
  }
  GLboolean MojoGLES2Impl::IsShader(GLuint shader) {
    MojoGLES2MakeCurrent(context_);
    return glIsShader(shader);
  }
  GLboolean MojoGLES2Impl::IsSync(GLsync sync) {
    NOTREACHED() << "Unimplemented IsSync.";
    return 0;
  }
  GLboolean MojoGLES2Impl::IsTexture(GLuint texture) {
    MojoGLES2MakeCurrent(context_);
    return glIsTexture(texture);
  }
  GLboolean MojoGLES2Impl::IsTransformFeedback(GLuint transformfeedback) {
    NOTREACHED() << "Unimplemented IsTransformFeedback.";
    return 0;
  }
  void MojoGLES2Impl::LineWidth(GLfloat width) {
    MojoGLES2MakeCurrent(context_);
    glLineWidth(width);
  }
  void MojoGLES2Impl::LinkProgram(GLuint program) {
    MojoGLES2MakeCurrent(context_);
    glLinkProgram(program);
  }
  void MojoGLES2Impl::PauseTransformFeedback() {
    NOTREACHED() << "Unimplemented PauseTransformFeedback.";
  }
  void MojoGLES2Impl::PixelStorei(GLenum pname, GLint param) {
    MojoGLES2MakeCurrent(context_);
    glPixelStorei(pname, param);
  }
  void MojoGLES2Impl::PolygonOffset(GLfloat factor, GLfloat units) {
    MojoGLES2MakeCurrent(context_);
    glPolygonOffset(factor, units);
  }
  void MojoGLES2Impl::ReadBuffer(GLenum src) {
    NOTREACHED() << "Unimplemented ReadBuffer.";
  }
  void MojoGLES2Impl::ReadPixels(GLint x,
                                 GLint y,
                                 GLsizei width,
                                 GLsizei height,
                                 GLenum format,
                                 GLenum type,
                                 void* pixels) {
    MojoGLES2MakeCurrent(context_);
    glReadPixels(x, y, width, height, format, type, pixels);
  }
  void MojoGLES2Impl::ReleaseShaderCompiler() {
    MojoGLES2MakeCurrent(context_);
    glReleaseShaderCompiler();
  }
  void MojoGLES2Impl::RenderbufferStorage(GLenum target,
                                          GLenum internalformat,
                                          GLsizei width,
                                          GLsizei height) {
    MojoGLES2MakeCurrent(context_);
    glRenderbufferStorage(target, internalformat, width, height);
  }
  void MojoGLES2Impl::ResumeTransformFeedback() {
    NOTREACHED() << "Unimplemented ResumeTransformFeedback.";
  }
  void MojoGLES2Impl::SampleCoverage(GLclampf value, GLboolean invert) {
    MojoGLES2MakeCurrent(context_);
    glSampleCoverage(value, invert);
  }
  void MojoGLES2Impl::SamplerParameterf(GLuint sampler,
                                        GLenum pname,
                                        GLfloat param) {
    NOTREACHED() << "Unimplemented SamplerParameterf.";
  }
  void MojoGLES2Impl::SamplerParameterfv(GLuint sampler,
                                         GLenum pname,
                                         const GLfloat* params) {
    NOTREACHED() << "Unimplemented SamplerParameterfv.";
  }
  void MojoGLES2Impl::SamplerParameteri(GLuint sampler,
                                        GLenum pname,
                                        GLint param) {
    NOTREACHED() << "Unimplemented SamplerParameteri.";
  }
  void MojoGLES2Impl::SamplerParameteriv(GLuint sampler,
                                         GLenum pname,
                                         const GLint* params) {
    NOTREACHED() << "Unimplemented SamplerParameteriv.";
  }
  void MojoGLES2Impl::Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
    MojoGLES2MakeCurrent(context_);
    glScissor(x, y, width, height);
  }
  void MojoGLES2Impl::ShaderBinary(GLsizei n,
                                   const GLuint* shaders,
                                   GLenum binaryformat,
                                   const void* binary,
                                   GLsizei length) {
    MojoGLES2MakeCurrent(context_);
    glShaderBinary(n, shaders, binaryformat, binary, length);
  }
  void MojoGLES2Impl::ShaderSource(GLuint shader,
                                   GLsizei count,
                                   const GLchar* const* str,
                                   const GLint* length) {
    MojoGLES2MakeCurrent(context_);
    glShaderSource(shader, count, str, length);
  }
  void MojoGLES2Impl::ShallowFinishCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glShallowFinishCHROMIUM();
  }
  void MojoGLES2Impl::ShallowFlushCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glShallowFlushCHROMIUM();
  }
  void MojoGLES2Impl::OrderingBarrierCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glOrderingBarrierCHROMIUM();
  }
  void MojoGLES2Impl::StencilFunc(GLenum func, GLint ref, GLuint mask) {
    MojoGLES2MakeCurrent(context_);
    glStencilFunc(func, ref, mask);
  }
  void MojoGLES2Impl::StencilFuncSeparate(GLenum face,
                                          GLenum func,
                                          GLint ref,
                                          GLuint mask) {
    MojoGLES2MakeCurrent(context_);
    glStencilFuncSeparate(face, func, ref, mask);
  }
  void MojoGLES2Impl::StencilMask(GLuint mask) {
    MojoGLES2MakeCurrent(context_);
    glStencilMask(mask);
  }
  void MojoGLES2Impl::StencilMaskSeparate(GLenum face, GLuint mask) {
    MojoGLES2MakeCurrent(context_);
    glStencilMaskSeparate(face, mask);
  }
  void MojoGLES2Impl::StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
    MojoGLES2MakeCurrent(context_);
    glStencilOp(fail, zfail, zpass);
  }
  void MojoGLES2Impl::StencilOpSeparate(GLenum face,
                                        GLenum fail,
                                        GLenum zfail,
                                        GLenum zpass) {
    MojoGLES2MakeCurrent(context_);
    glStencilOpSeparate(face, fail, zfail, zpass);
  }
  void MojoGLES2Impl::TexImage2D(GLenum target,
                                 GLint level,
                                 GLint internalformat,
                                 GLsizei width,
                                 GLsizei height,
                                 GLint border,
                                 GLenum format,
                                 GLenum type,
                                 const void* pixels) {
    MojoGLES2MakeCurrent(context_);
    glTexImage2D(target, level, internalformat, width, height, border, format,
                 type, pixels);
  }
  void MojoGLES2Impl::TexImage3D(GLenum target,
                                 GLint level,
                                 GLint internalformat,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLint border,
                                 GLenum format,
                                 GLenum type,
                                 const void* pixels) {
    NOTREACHED() << "Unimplemented TexImage3D.";
  }
  void MojoGLES2Impl::TexParameterf(GLenum target, GLenum pname, GLfloat param) {
    MojoGLES2MakeCurrent(context_);
    glTexParameterf(target, pname, param);
  }
  void MojoGLES2Impl::TexParameterfv(GLenum target,
                                     GLenum pname,
                                     const GLfloat* params) {
    MojoGLES2MakeCurrent(context_);
    glTexParameterfv(target, pname, params);
  }
  void MojoGLES2Impl::TexParameteri(GLenum target, GLenum pname, GLint param) {
    MojoGLES2MakeCurrent(context_);
    glTexParameteri(target, pname, param);
  }
  void MojoGLES2Impl::TexParameteriv(GLenum target,
                                     GLenum pname,
                                     const GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glTexParameteriv(target, pname, params);
  }
  void MojoGLES2Impl::TexStorage3D(GLenum target,
                                   GLsizei levels,
                                   GLenum internalFormat,
                                   GLsizei width,
                                   GLsizei height,
                                   GLsizei depth) {
    NOTREACHED() << "Unimplemented TexStorage3D.";
  }
  void MojoGLES2Impl::TexSubImage2D(GLenum target,
                                    GLint level,
                                    GLint xoffset,
                                    GLint yoffset,
                                    GLsizei width,
                                    GLsizei height,
                                    GLenum format,
                                    GLenum type,
                                    const void* pixels) {
    MojoGLES2MakeCurrent(context_);
    glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
                    pixels);
  }
  void MojoGLES2Impl::TexSubImage3D(GLenum target,
                                    GLint level,
                                    GLint xoffset,
                                    GLint yoffset,
                                    GLint zoffset,
                                    GLsizei width,
                                    GLsizei height,
                                    GLsizei depth,
                                    GLenum format,
                                    GLenum type,
                                    const void* pixels) {
    NOTREACHED() << "Unimplemented TexSubImage3D.";
  }
  void MojoGLES2Impl::TransformFeedbackVaryings(GLuint program,
                                                GLsizei count,
                                                const char* const* varyings,
                                                GLenum buffermode) {
    NOTREACHED() << "Unimplemented TransformFeedbackVaryings.";
  }
  void MojoGLES2Impl::Uniform1f(GLint location, GLfloat x) {
    MojoGLES2MakeCurrent(context_);
    glUniform1f(location, x);
  }
  void MojoGLES2Impl::Uniform1fv(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
    MojoGLES2MakeCurrent(context_);
    glUniform1fv(location, count, v);
  }
  void MojoGLES2Impl::Uniform1i(GLint location, GLint x) {
    MojoGLES2MakeCurrent(context_);
    glUniform1i(location, x);
  }
  void MojoGLES2Impl::Uniform1iv(GLint location, GLsizei count, const GLint* v) {
    MojoGLES2MakeCurrent(context_);
    glUniform1iv(location, count, v);
  }
  void MojoGLES2Impl::Uniform1ui(GLint location, GLuint x) {
    NOTREACHED() << "Unimplemented Uniform1ui.";
  }
  void MojoGLES2Impl::Uniform1uiv(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
    NOTREACHED() << "Unimplemented Uniform1uiv.";
  }
  void MojoGLES2Impl::Uniform2f(GLint location, GLfloat x, GLfloat y) {
    MojoGLES2MakeCurrent(context_);
    glUniform2f(location, x, y);
  }
  void MojoGLES2Impl::Uniform2fv(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
    MojoGLES2MakeCurrent(context_);
    glUniform2fv(location, count, v);
  }
  void MojoGLES2Impl::Uniform2i(GLint location, GLint x, GLint y) {
    MojoGLES2MakeCurrent(context_);
    glUniform2i(location, x, y);
  }
  void MojoGLES2Impl::Uniform2iv(GLint location, GLsizei count, const GLint* v) {
    MojoGLES2MakeCurrent(context_);
    glUniform2iv(location, count, v);
  }
  void MojoGLES2Impl::Uniform2ui(GLint location, GLuint x, GLuint y) {
    NOTREACHED() << "Unimplemented Uniform2ui.";
  }
  void MojoGLES2Impl::Uniform2uiv(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
    NOTREACHED() << "Unimplemented Uniform2uiv.";
  }
  void MojoGLES2Impl::Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
    MojoGLES2MakeCurrent(context_);
    glUniform3f(location, x, y, z);
  }
  void MojoGLES2Impl::Uniform3fv(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
    MojoGLES2MakeCurrent(context_);
    glUniform3fv(location, count, v);
  }
  void MojoGLES2Impl::Uniform3i(GLint location, GLint x, GLint y, GLint z) {
    MojoGLES2MakeCurrent(context_);
    glUniform3i(location, x, y, z);
  }
  void MojoGLES2Impl::Uniform3iv(GLint location, GLsizei count, const GLint* v) {
    MojoGLES2MakeCurrent(context_);
    glUniform3iv(location, count, v);
  }
  void MojoGLES2Impl::Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
    NOTREACHED() << "Unimplemented Uniform3ui.";
  }
  void MojoGLES2Impl::Uniform3uiv(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
    NOTREACHED() << "Unimplemented Uniform3uiv.";
  }
  void MojoGLES2Impl::Uniform4f(GLint location,
                                GLfloat x,
                                GLfloat y,
                                GLfloat z,
                                GLfloat w) {
    MojoGLES2MakeCurrent(context_);
    glUniform4f(location, x, y, z, w);
  }
  void MojoGLES2Impl::Uniform4fv(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
    MojoGLES2MakeCurrent(context_);
    glUniform4fv(location, count, v);
  }
  void MojoGLES2Impl::Uniform4i(GLint location,
                                GLint x,
                                GLint y,
                                GLint z,
                                GLint w) {
    MojoGLES2MakeCurrent(context_);
    glUniform4i(location, x, y, z, w);
  }
  void MojoGLES2Impl::Uniform4iv(GLint location, GLsizei count, const GLint* v) {
    MojoGLES2MakeCurrent(context_);
    glUniform4iv(location, count, v);
  }
  void MojoGLES2Impl::Uniform4ui(GLint location,
                                 GLuint x,
                                 GLuint y,
                                 GLuint z,
                                 GLuint w) {
    NOTREACHED() << "Unimplemented Uniform4ui.";
  }
  void MojoGLES2Impl::Uniform4uiv(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
    NOTREACHED() << "Unimplemented Uniform4uiv.";
  }
  void MojoGLES2Impl::UniformBlockBinding(GLuint program,
                                          GLuint index,
                                          GLuint binding) {
    NOTREACHED() << "Unimplemented UniformBlockBinding.";
  }
  void MojoGLES2Impl::UniformMatrix2fv(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat* value) {
    MojoGLES2MakeCurrent(context_);
    glUniformMatrix2fv(location, count, transpose, value);
  }
  void MojoGLES2Impl::UniformMatrix2x3fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) {
    NOTREACHED() << "Unimplemented UniformMatrix2x3fv.";
  }
  void MojoGLES2Impl::UniformMatrix2x4fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) {
    NOTREACHED() << "Unimplemented UniformMatrix2x4fv.";
  }
  void MojoGLES2Impl::UniformMatrix3fv(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat* value) {
    MojoGLES2MakeCurrent(context_);
    glUniformMatrix3fv(location, count, transpose, value);
  }
  void MojoGLES2Impl::UniformMatrix3x2fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) {
    NOTREACHED() << "Unimplemented UniformMatrix3x2fv.";
  }
  void MojoGLES2Impl::UniformMatrix3x4fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) {
    NOTREACHED() << "Unimplemented UniformMatrix3x4fv.";
  }
  void MojoGLES2Impl::UniformMatrix4fv(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat* value) {
    MojoGLES2MakeCurrent(context_);
    glUniformMatrix4fv(location, count, transpose, value);
  }
  void MojoGLES2Impl::UniformMatrix4x2fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) {
    NOTREACHED() << "Unimplemented UniformMatrix4x2fv.";
  }
  void MojoGLES2Impl::UniformMatrix4x3fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) {
    NOTREACHED() << "Unimplemented UniformMatrix4x3fv.";
  }
  void MojoGLES2Impl::UseProgram(GLuint program) {
    MojoGLES2MakeCurrent(context_);
    glUseProgram(program);
  }
  void MojoGLES2Impl::ValidateProgram(GLuint program) {
    MojoGLES2MakeCurrent(context_);
    glValidateProgram(program);
  }
  void MojoGLES2Impl::VertexAttrib1f(GLuint indx, GLfloat x) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttrib1f(indx, x);
  }
  void MojoGLES2Impl::VertexAttrib1fv(GLuint indx, const GLfloat* values) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttrib1fv(indx, values);
  }
  void MojoGLES2Impl::VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttrib2f(indx, x, y);
  }
  void MojoGLES2Impl::VertexAttrib2fv(GLuint indx, const GLfloat* values) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttrib2fv(indx, values);
  }
  void MojoGLES2Impl::VertexAttrib3f(GLuint indx,
                                     GLfloat x,
                                     GLfloat y,
                                     GLfloat z) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttrib3f(indx, x, y, z);
  }
  void MojoGLES2Impl::VertexAttrib3fv(GLuint indx, const GLfloat* values) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttrib3fv(indx, values);
  }
  void MojoGLES2Impl::VertexAttrib4f(GLuint indx,
                                     GLfloat x,
                                     GLfloat y,
                                     GLfloat z,
                                     GLfloat w) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttrib4f(indx, x, y, z, w);
  }
  void MojoGLES2Impl::VertexAttrib4fv(GLuint indx, const GLfloat* values) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttrib4fv(indx, values);
  }
  void MojoGLES2Impl::VertexAttribI4i(GLuint indx,
                                      GLint x,
                                      GLint y,
                                      GLint z,
                                      GLint w) {
    NOTREACHED() << "Unimplemented VertexAttribI4i.";
  }
  void MojoGLES2Impl::VertexAttribI4iv(GLuint indx, const GLint* values) {
    NOTREACHED() << "Unimplemented VertexAttribI4iv.";
  }
  void MojoGLES2Impl::VertexAttribI4ui(GLuint indx,
                                       GLuint x,
                                       GLuint y,
                                       GLuint z,
                                       GLuint w) {
    NOTREACHED() << "Unimplemented VertexAttribI4ui.";
  }
  void MojoGLES2Impl::VertexAttribI4uiv(GLuint indx, const GLuint* values) {
    NOTREACHED() << "Unimplemented VertexAttribI4uiv.";
  }
  void MojoGLES2Impl::VertexAttribIPointer(GLuint indx,
                                           GLint size,
                                           GLenum type,
                                           GLsizei stride,
                                           const void* ptr) {
    NOTREACHED() << "Unimplemented VertexAttribIPointer.";
  }
  void MojoGLES2Impl::VertexAttribPointer(GLuint indx,
                                          GLint size,
                                          GLenum type,
                                          GLboolean normalized,
                                          GLsizei stride,
                                          const void* ptr) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
  }
  void MojoGLES2Impl::Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
    MojoGLES2MakeCurrent(context_);
    glViewport(x, y, width, height);
  }
  void MojoGLES2Impl::WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
    NOTREACHED() << "Unimplemented WaitSync.";
  }
  void MojoGLES2Impl::BlitFramebufferCHROMIUM(GLint srcX0,
                                              GLint srcY0,
                                              GLint srcX1,
                                              GLint srcY1,
                                              GLint dstX0,
                                              GLint dstY0,
                                              GLint dstX1,
                                              GLint dstY1,
                                              GLbitfield mask,
                                              GLenum filter) {
    MojoGLES2MakeCurrent(context_);
    glBlitFramebufferCHROMIUM(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
                              dstY1, mask, filter);
  }
  void MojoGLES2Impl::RenderbufferStorageMultisampleCHROMIUM(
      GLenum target,
      GLsizei samples,
      GLenum internalformat,
      GLsizei width,
      GLsizei height) {
    MojoGLES2MakeCurrent(context_);
    glRenderbufferStorageMultisampleCHROMIUM(target, samples, internalformat,
                                             width, height);
  }
  void MojoGLES2Impl::RenderbufferStorageMultisampleEXT(GLenum target,
                                                        GLsizei samples,
                                                        GLenum internalformat,
                                                        GLsizei width,
                                                        GLsizei height) {
    MojoGLES2MakeCurrent(context_);
    glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width,
                                        height);
  }
  void MojoGLES2Impl::FramebufferTexture2DMultisampleEXT(GLenum target,
                                                         GLenum attachment,
                                                         GLenum textarget,
                                                         GLuint texture,
                                                         GLint level,
                                                         GLsizei samples) {
    MojoGLES2MakeCurrent(context_);
    glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture,
                                         level, samples);
  }
  void MojoGLES2Impl::TexStorage2DEXT(GLenum target,
                                      GLsizei levels,
                                      GLenum internalFormat,
                                      GLsizei width,
                                      GLsizei height) {
    MojoGLES2MakeCurrent(context_);
    glTexStorage2DEXT(target, levels, internalFormat, width, height);
  }
  void MojoGLES2Impl::GenQueriesEXT(GLsizei n, GLuint* queries) {
    MojoGLES2MakeCurrent(context_);
    glGenQueriesEXT(n, queries);
  }
  void MojoGLES2Impl::DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
    MojoGLES2MakeCurrent(context_);
    glDeleteQueriesEXT(n, queries);
  }
  void MojoGLES2Impl::QueryCounterEXT(GLuint id, GLenum target) {
    MojoGLES2MakeCurrent(context_);
    glQueryCounterEXT(id, target);
  }
  GLboolean MojoGLES2Impl::IsQueryEXT(GLuint id) {
    MojoGLES2MakeCurrent(context_);
    return glIsQueryEXT(id);
  }
  void MojoGLES2Impl::BeginQueryEXT(GLenum target, GLuint id) {
    MojoGLES2MakeCurrent(context_);
    glBeginQueryEXT(target, id);
  }
  void MojoGLES2Impl::BeginTransformFeedback(GLenum primitivemode) {
    NOTREACHED() << "Unimplemented BeginTransformFeedback.";
  }
  void MojoGLES2Impl::EndQueryEXT(GLenum target) {
    MojoGLES2MakeCurrent(context_);
    glEndQueryEXT(target);
  }
  void MojoGLES2Impl::EndTransformFeedback() {
    NOTREACHED() << "Unimplemented EndTransformFeedback.";
  }
  void MojoGLES2Impl::GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetQueryivEXT(target, pname, params);
  }
  void MojoGLES2Impl::GetQueryObjectivEXT(GLuint id,
                                          GLenum pname,
                                          GLint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetQueryObjectivEXT(id, pname, params);
  }
  void MojoGLES2Impl::GetQueryObjectuivEXT(GLuint id,
                                           GLenum pname,
                                           GLuint* params) {
    MojoGLES2MakeCurrent(context_);
    glGetQueryObjectuivEXT(id, pname, params);
  }
  void MojoGLES2Impl::GetQueryObjecti64vEXT(GLuint id,
                                            GLenum pname,
                                            GLint64* params) {
    MojoGLES2MakeCurrent(context_);
    glGetQueryObjecti64vEXT(id, pname, params);
  }
  void MojoGLES2Impl::GetQueryObjectui64vEXT(GLuint id,
                                             GLenum pname,
                                             GLuint64* params) {
    MojoGLES2MakeCurrent(context_);
    glGetQueryObjectui64vEXT(id, pname, params);
  }
  void MojoGLES2Impl::SetDisjointValueSyncCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glSetDisjointValueSyncCHROMIUM();
  }
  void MojoGLES2Impl::InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
    MojoGLES2MakeCurrent(context_);
    glInsertEventMarkerEXT(length, marker);
  }
  void MojoGLES2Impl::PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
    MojoGLES2MakeCurrent(context_);
    glPushGroupMarkerEXT(length, marker);
  }
  void MojoGLES2Impl::PopGroupMarkerEXT() {
    MojoGLES2MakeCurrent(context_);
    glPopGroupMarkerEXT();
  }
  void MojoGLES2Impl::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
    MojoGLES2MakeCurrent(context_);
    glGenVertexArraysOES(n, arrays);
  }
  void MojoGLES2Impl::DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
    MojoGLES2MakeCurrent(context_);
    glDeleteVertexArraysOES(n, arrays);
  }
  GLboolean MojoGLES2Impl::IsVertexArrayOES(GLuint array) {
    MojoGLES2MakeCurrent(context_);
    return glIsVertexArrayOES(array);
  }
  void MojoGLES2Impl::BindVertexArrayOES(GLuint array) {
    MojoGLES2MakeCurrent(context_);
    glBindVertexArrayOES(array);
  }
  void MojoGLES2Impl::SwapBuffers() {
    MojoGLES2MakeCurrent(context_);
    glSwapBuffers();
  }
  GLuint MojoGLES2Impl::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
                                                    GLsizei count,
                                                    GLenum type,
                                                    GLuint offset) {
    MojoGLES2MakeCurrent(context_);
    return glGetMaxValueInBufferCHROMIUM(buffer_id, count, type, offset);
  }
  GLboolean MojoGLES2Impl::EnableFeatureCHROMIUM(const char* feature) {
    MojoGLES2MakeCurrent(context_);
    return glEnableFeatureCHROMIUM(feature);
  }
  void* MojoGLES2Impl::MapBufferCHROMIUM(GLuint target, GLenum access) {
    MojoGLES2MakeCurrent(context_);
    return glMapBufferCHROMIUM(target, access);
  }
  GLboolean MojoGLES2Impl::UnmapBufferCHROMIUM(GLuint target) {
    MojoGLES2MakeCurrent(context_);
    return glUnmapBufferCHROMIUM(target);
  }
  void* MojoGLES2Impl::MapBufferSubDataCHROMIUM(GLuint target,
                                                GLintptr offset,
                                                GLsizeiptr size,
                                                GLenum access) {
    MojoGLES2MakeCurrent(context_);
    return glMapBufferSubDataCHROMIUM(target, offset, size, access);
  }
  void MojoGLES2Impl::UnmapBufferSubDataCHROMIUM(const void* mem) {
    MojoGLES2MakeCurrent(context_);
    glUnmapBufferSubDataCHROMIUM(mem);
  }
  void* MojoGLES2Impl::MapBufferRange(GLenum target,
                                      GLintptr offset,
                                      GLsizeiptr size,
                                      GLbitfield access) {
    NOTREACHED() << "Unimplemented MapBufferRange.";
    return 0;
  }
  GLboolean MojoGLES2Impl::UnmapBuffer(GLenum target) {
    NOTREACHED() << "Unimplemented UnmapBuffer.";
    return 0;
  }
  void* MojoGLES2Impl::MapTexSubImage2DCHROMIUM(GLenum target,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLenum format,
                                                GLenum type,
                                                GLenum access) {
    MojoGLES2MakeCurrent(context_);
    return glMapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
                                      height, format, type, access);
  }
  void MojoGLES2Impl::UnmapTexSubImage2DCHROMIUM(const void* mem) {
    MojoGLES2MakeCurrent(context_);
    glUnmapTexSubImage2DCHROMIUM(mem);
  }
  void MojoGLES2Impl::ResizeCHROMIUM(GLuint width,
                                     GLuint height,
                                     GLfloat scale_factor,
                                     GLboolean alpha) {
    MojoGLES2MakeCurrent(context_);
    glResizeCHROMIUM(width, height, scale_factor, alpha);
  }
  const GLchar* MojoGLES2Impl::GetRequestableExtensionsCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    return glGetRequestableExtensionsCHROMIUM();
  }
  void MojoGLES2Impl::RequestExtensionCHROMIUM(const char* extension) {
    MojoGLES2MakeCurrent(context_);
    glRequestExtensionCHROMIUM(extension);
  }
  void MojoGLES2Impl::GetProgramInfoCHROMIUM(GLuint program,
                                             GLsizei bufsize,
                                             GLsizei* size,
                                             void* info) {
    MojoGLES2MakeCurrent(context_);
    glGetProgramInfoCHROMIUM(program, bufsize, size, info);
  }
  void MojoGLES2Impl::GetUniformBlocksCHROMIUM(GLuint program,
                                               GLsizei bufsize,
                                               GLsizei* size,
                                               void* info) {
    NOTREACHED() << "Unimplemented GetUniformBlocksCHROMIUM.";
  }
  void MojoGLES2Impl::GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
                                                           GLsizei bufsize,
                                                           GLsizei* size,
                                                           void* info) {
    NOTREACHED() << "Unimplemented GetTransformFeedbackVaryingsCHROMIUM.";
  }
  void MojoGLES2Impl::GetUniformsES3CHROMIUM(GLuint program,
                                             GLsizei bufsize,
                                             GLsizei* size,
                                             void* info) {
    NOTREACHED() << "Unimplemented GetUniformsES3CHROMIUM.";
  }
  GLuint MojoGLES2Impl::CreateImageCHROMIUM(ClientBuffer buffer,
                                            GLsizei width,
                                            GLsizei height,
                                            GLenum internalformat) {
    MojoGLES2MakeCurrent(context_);
    return glCreateImageCHROMIUM(buffer, width, height, internalformat);
  }
  void MojoGLES2Impl::DestroyImageCHROMIUM(GLuint image_id) {
    MojoGLES2MakeCurrent(context_);
    glDestroyImageCHROMIUM(image_id);
  }
  GLuint MojoGLES2Impl::CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
                                                           GLsizei height,
                                                           GLenum internalformat,
                                                           GLenum usage) {
    MojoGLES2MakeCurrent(context_);
    return glCreateGpuMemoryBufferImageCHROMIUM(width, height, internalformat,
                                                usage);
  }
  void MojoGLES2Impl::GetTranslatedShaderSourceANGLE(GLuint shader,
                                                     GLsizei bufsize,
                                                     GLsizei* length,
                                                     char* source) {
    MojoGLES2MakeCurrent(context_);
    glGetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
  }
  void MojoGLES2Impl::PostSubBufferCHROMIUM(GLint x,
                                            GLint y,
                                            GLint width,
                                            GLint height) {
    MojoGLES2MakeCurrent(context_);
    glPostSubBufferCHROMIUM(x, y, width, height);
  }
  void MojoGLES2Impl::CopyTextureCHROMIUM(GLenum source_id,
                                          GLenum dest_id,
                                          GLint internalformat,
                                          GLenum dest_type,
                                          GLboolean unpack_flip_y,
                                          GLboolean unpack_premultiply_alpha,
                                          GLboolean unpack_unmultiply_alpha) {
    MojoGLES2MakeCurrent(context_);
    glCopyTextureCHROMIUM(source_id, dest_id, internalformat, dest_type,
                          unpack_flip_y, unpack_premultiply_alpha,
                          unpack_unmultiply_alpha);
  }
  void MojoGLES2Impl::CopySubTextureCHROMIUM(GLenum source_id,
                                             GLenum dest_id,
                                             GLint xoffset,
                                             GLint yoffset,
                                             GLint x,
                                             GLint y,
                                             GLsizei width,
                                             GLsizei height,
                                             GLboolean unpack_flip_y,
                                             GLboolean unpack_premultiply_alpha,
                                             GLboolean unpack_unmultiply_alpha) {
    MojoGLES2MakeCurrent(context_);
    glCopySubTextureCHROMIUM(source_id, dest_id, xoffset, yoffset, x, y, width,
                             height, unpack_flip_y, unpack_premultiply_alpha,
                             unpack_unmultiply_alpha);
  }
  void MojoGLES2Impl::CompressedCopyTextureCHROMIUM(GLenum source_id,
                                                    GLenum dest_id) {
    MojoGLES2MakeCurrent(context_);
    glCompressedCopyTextureCHROMIUM(source_id, dest_id);
  }
  void MojoGLES2Impl::DrawArraysInstancedANGLE(GLenum mode,
                                               GLint first,
                                               GLsizei count,
                                               GLsizei primcount) {
    MojoGLES2MakeCurrent(context_);
    glDrawArraysInstancedANGLE(mode, first, count, primcount);
  }
  void MojoGLES2Impl::DrawElementsInstancedANGLE(GLenum mode,
                                                 GLsizei count,
                                                 GLenum type,
                                                 const void* indices,
                                                 GLsizei primcount) {
    MojoGLES2MakeCurrent(context_);
    glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
  }
  void MojoGLES2Impl::VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
    MojoGLES2MakeCurrent(context_);
    glVertexAttribDivisorANGLE(index, divisor);
  }
  void MojoGLES2Impl::GenMailboxCHROMIUM(GLbyte* mailbox) {
    MojoGLES2MakeCurrent(context_);
    glGenMailboxCHROMIUM(mailbox);
  }
  void MojoGLES2Impl::ProduceTextureCHROMIUM(GLenum target,
                                             const GLbyte* mailbox) {
    MojoGLES2MakeCurrent(context_);
    glProduceTextureCHROMIUM(target, mailbox);
  }
  void MojoGLES2Impl::ProduceTextureDirectCHROMIUM(GLuint texture,
                                                   GLenum target,
                                                   const GLbyte* mailbox) {
    MojoGLES2MakeCurrent(context_);
    glProduceTextureDirectCHROMIUM(texture, target, mailbox);
  }
  void MojoGLES2Impl::ConsumeTextureCHROMIUM(GLenum target,
                                             const GLbyte* mailbox) {
    MojoGLES2MakeCurrent(context_);
    glConsumeTextureCHROMIUM(target, mailbox);
  }
  GLuint MojoGLES2Impl::CreateAndConsumeTextureCHROMIUM(GLenum target,
                                                        const GLbyte* mailbox) {
    MojoGLES2MakeCurrent(context_);
    return glCreateAndConsumeTextureCHROMIUM(target, mailbox);
  }
  void MojoGLES2Impl::BindUniformLocationCHROMIUM(GLuint program,
                                                  GLint location,
                                                  const char* name) {
    MojoGLES2MakeCurrent(context_);
    glBindUniformLocationCHROMIUM(program, location, name);
  }
  void MojoGLES2Impl::BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
    MojoGLES2MakeCurrent(context_);
    glBindTexImage2DCHROMIUM(target, imageId);
  }
  void MojoGLES2Impl::ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
    MojoGLES2MakeCurrent(context_);
    glReleaseTexImage2DCHROMIUM(target, imageId);
  }
  void MojoGLES2Impl::TraceBeginCHROMIUM(const char* category_name,
                                         const char* trace_name) {
    MojoGLES2MakeCurrent(context_);
    glTraceBeginCHROMIUM(category_name, trace_name);
  }
  void MojoGLES2Impl::TraceEndCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glTraceEndCHROMIUM();
  }
  void MojoGLES2Impl::DiscardFramebufferEXT(GLenum target,
                                            GLsizei count,
                                            const GLenum* attachments) {
    MojoGLES2MakeCurrent(context_);
    glDiscardFramebufferEXT(target, count, attachments);
  }
  void MojoGLES2Impl::LoseContextCHROMIUM(GLenum current, GLenum other) {
    MojoGLES2MakeCurrent(context_);
    glLoseContextCHROMIUM(current, other);
  }
  GLuint64 MojoGLES2Impl::InsertFenceSyncCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    return glInsertFenceSyncCHROMIUM();
  }
  void MojoGLES2Impl::GenSyncTokenCHROMIUM(GLuint64 fence_sync,
                                           GLbyte* sync_token) {
    MojoGLES2MakeCurrent(context_);
    glGenSyncTokenCHROMIUM(fence_sync, sync_token);
  }
  void MojoGLES2Impl::GenUnverifiedSyncTokenCHROMIUM(GLuint64 fence_sync,
                                                     GLbyte* sync_token) {
    MojoGLES2MakeCurrent(context_);
    glGenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token);
  }
  void MojoGLES2Impl::VerifySyncTokensCHROMIUM(GLbyte** sync_tokens,
                                               GLsizei count) {
    MojoGLES2MakeCurrent(context_);
    glVerifySyncTokensCHROMIUM(sync_tokens, count);
  }
  void MojoGLES2Impl::WaitSyncTokenCHROMIUM(const GLbyte* sync_token) {
    MojoGLES2MakeCurrent(context_);
    glWaitSyncTokenCHROMIUM(sync_token);
  }
  void MojoGLES2Impl::DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
    MojoGLES2MakeCurrent(context_);
    glDrawBuffersEXT(count, bufs);
  }
  void MojoGLES2Impl::DiscardBackbufferCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glDiscardBackbufferCHROMIUM();
  }
  void MojoGLES2Impl::ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
                                                   GLenum plane_transform,
                                                   GLuint overlay_texture_id,
                                                   GLint bounds_x,
                                                   GLint bounds_y,
                                                   GLint bounds_width,
                                                   GLint bounds_height,
                                                   GLfloat uv_x,
                                                   GLfloat uv_y,
                                                   GLfloat uv_width,
                                                   GLfloat uv_height) {
    MojoGLES2MakeCurrent(context_);
    glScheduleOverlayPlaneCHROMIUM(
        plane_z_order, plane_transform, overlay_texture_id, bounds_x, bounds_y,
        bounds_width, bounds_height, uv_x, uv_y, uv_width, uv_height);
  }
  void MojoGLES2Impl::ScheduleCALayerCHROMIUM(GLuint contents_texture_id,
                                              const GLfloat* contents_rect,
                                              GLfloat opacity,
                                              GLuint background_color,
                                              GLuint edge_aa_mask,
                                              const GLfloat* bounds_rect,
                                              GLboolean is_clipped,
                                              const GLfloat* clip_rect,
                                              GLint sorting_context_id,
                                              const GLfloat* transform,
                                              GLuint filter) {
    MojoGLES2MakeCurrent(context_);
    glScheduleCALayerCHROMIUM(contents_texture_id, contents_rect, opacity,
                              background_color, edge_aa_mask, bounds_rect,
                              is_clipped, clip_rect, sorting_context_id,
                              transform, filter);
  }
  void MojoGLES2Impl::CommitOverlayPlanesCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glCommitOverlayPlanesCHROMIUM();
  }
  void MojoGLES2Impl::SwapInterval(GLint interval) {
    MojoGLES2MakeCurrent(context_);
    glSwapInterval(interval);
  }
  void MojoGLES2Impl::FlushDriverCachesCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glFlushDriverCachesCHROMIUM();
  }
  GLuint MojoGLES2Impl::GetLastFlushIdCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    return glGetLastFlushIdCHROMIUM();
  }
  void MojoGLES2Impl::MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
    MojoGLES2MakeCurrent(context_);
    glMatrixLoadfCHROMIUM(matrixMode, m);
  }
  void MojoGLES2Impl::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
    MojoGLES2MakeCurrent(context_);
    glMatrixLoadIdentityCHROMIUM(matrixMode);
  }
  GLuint MojoGLES2Impl::GenPathsCHROMIUM(GLsizei range) {
    MojoGLES2MakeCurrent(context_);
    return glGenPathsCHROMIUM(range);
  }
  void MojoGLES2Impl::DeletePathsCHROMIUM(GLuint path, GLsizei range) {
    MojoGLES2MakeCurrent(context_);
    glDeletePathsCHROMIUM(path, range);
  }
  GLboolean MojoGLES2Impl::IsPathCHROMIUM(GLuint path) {
    MojoGLES2MakeCurrent(context_);
    return glIsPathCHROMIUM(path);
  }
  void MojoGLES2Impl::PathCommandsCHROMIUM(GLuint path,
                                           GLsizei numCommands,
                                           const GLubyte* commands,
                                           GLsizei numCoords,
                                           GLenum coordType,
                                           const GLvoid* coords) {
    MojoGLES2MakeCurrent(context_);
    glPathCommandsCHROMIUM(path, numCommands, commands, numCoords, coordType,
                           coords);
  }
  void MojoGLES2Impl::PathParameterfCHROMIUM(GLuint path,
                                             GLenum pname,
                                             GLfloat value) {
    MojoGLES2MakeCurrent(context_);
    glPathParameterfCHROMIUM(path, pname, value);
  }
  void MojoGLES2Impl::PathParameteriCHROMIUM(GLuint path,
                                             GLenum pname,
                                             GLint value) {
    MojoGLES2MakeCurrent(context_);
    glPathParameteriCHROMIUM(path, pname, value);
  }
  void MojoGLES2Impl::PathStencilFuncCHROMIUM(GLenum func,
                                              GLint ref,
                                              GLuint mask) {
    MojoGLES2MakeCurrent(context_);
    glPathStencilFuncCHROMIUM(func, ref, mask);
  }
  void MojoGLES2Impl::StencilFillPathCHROMIUM(GLuint path,
                                              GLenum fillMode,
                                              GLuint mask) {
    MojoGLES2MakeCurrent(context_);
    glStencilFillPathCHROMIUM(path, fillMode, mask);
  }
  void MojoGLES2Impl::StencilStrokePathCHROMIUM(GLuint path,
                                                GLint reference,
                                                GLuint mask) {
    MojoGLES2MakeCurrent(context_);
    glStencilStrokePathCHROMIUM(path, reference, mask);
  }
  void MojoGLES2Impl::CoverFillPathCHROMIUM(GLuint path, GLenum coverMode) {
    MojoGLES2MakeCurrent(context_);
    glCoverFillPathCHROMIUM(path, coverMode);
  }
  void MojoGLES2Impl::CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode) {
    MojoGLES2MakeCurrent(context_);
    glCoverStrokePathCHROMIUM(path, coverMode);
  }
  void MojoGLES2Impl::StencilThenCoverFillPathCHROMIUM(GLuint path,
                                                       GLenum fillMode,
                                                       GLuint mask,
                                                       GLenum coverMode) {
    MojoGLES2MakeCurrent(context_);
    glStencilThenCoverFillPathCHROMIUM(path, fillMode, mask, coverMode);
  }
  void MojoGLES2Impl::StencilThenCoverStrokePathCHROMIUM(GLuint path,
                                                         GLint reference,
                                                         GLuint mask,
                                                         GLenum coverMode) {
    MojoGLES2MakeCurrent(context_);
    glStencilThenCoverStrokePathCHROMIUM(path, reference, mask, coverMode);
  }
  void MojoGLES2Impl::StencilFillPathInstancedCHROMIUM(
      GLsizei numPaths,
      GLenum pathNameType,
      const GLvoid* paths,
      GLuint pathBase,
      GLenum fillMode,
      GLuint mask,
      GLenum transformType,
      const GLfloat* transformValues) {
    MojoGLES2MakeCurrent(context_);
    glStencilFillPathInstancedCHROMIUM(numPaths, pathNameType, paths, pathBase,
                                       fillMode, mask, transformType,
                                       transformValues);
  }
  void MojoGLES2Impl::StencilStrokePathInstancedCHROMIUM(
      GLsizei numPaths,
      GLenum pathNameType,
      const GLvoid* paths,
      GLuint pathBase,
      GLint reference,
      GLuint mask,
      GLenum transformType,
      const GLfloat* transformValues) {
    MojoGLES2MakeCurrent(context_);
    glStencilStrokePathInstancedCHROMIUM(numPaths, pathNameType, paths, pathBase,
                                         reference, mask, transformType,
                                         transformValues);
  }
  void MojoGLES2Impl::CoverFillPathInstancedCHROMIUM(
      GLsizei numPaths,
      GLenum pathNameType,
      const GLvoid* paths,
      GLuint pathBase,
      GLenum coverMode,
      GLenum transformType,
      const GLfloat* transformValues) {
    MojoGLES2MakeCurrent(context_);
    glCoverFillPathInstancedCHROMIUM(numPaths, pathNameType, paths, pathBase,
                                     coverMode, transformType, transformValues);
  }
  void MojoGLES2Impl::CoverStrokePathInstancedCHROMIUM(
      GLsizei numPaths,
      GLenum pathNameType,
      const GLvoid* paths,
      GLuint pathBase,
      GLenum coverMode,
      GLenum transformType,
      const GLfloat* transformValues) {
    MojoGLES2MakeCurrent(context_);
    glCoverStrokePathInstancedCHROMIUM(numPaths, pathNameType, paths, pathBase,
                                       coverMode, transformType, transformValues);
  }
  void MojoGLES2Impl::StencilThenCoverFillPathInstancedCHROMIUM(
      GLsizei numPaths,
      GLenum pathNameType,
      const GLvoid* paths,
      GLuint pathBase,
      GLenum fillMode,
      GLuint mask,
      GLenum coverMode,
      GLenum transformType,
      const GLfloat* transformValues) {
    MojoGLES2MakeCurrent(context_);
    glStencilThenCoverFillPathInstancedCHROMIUM(
        numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
        transformType, transformValues);
  }
  void MojoGLES2Impl::StencilThenCoverStrokePathInstancedCHROMIUM(
      GLsizei numPaths,
      GLenum pathNameType,
      const GLvoid* paths,
      GLuint pathBase,
      GLint reference,
      GLuint mask,
      GLenum coverMode,
      GLenum transformType,
      const GLfloat* transformValues) {
    MojoGLES2MakeCurrent(context_);
    glStencilThenCoverStrokePathInstancedCHROMIUM(
        numPaths, pathNameType, paths, pathBase, reference, mask, coverMode,
        transformType, transformValues);
  }
  void MojoGLES2Impl::BindFragmentInputLocationCHROMIUM(GLuint program,
                                                        GLint location,
                                                        const char* name) {
    MojoGLES2MakeCurrent(context_);
    glBindFragmentInputLocationCHROMIUM(program, location, name);
  }
  void MojoGLES2Impl::ProgramPathFragmentInputGenCHROMIUM(GLuint program,
                                                          GLint location,
                                                          GLenum genMode,
                                                          GLint components,
                                                          const GLfloat* coeffs) {
    MojoGLES2MakeCurrent(context_);
    glProgramPathFragmentInputGenCHROMIUM(program, location, genMode, components,
                                          coeffs);
  }
  void MojoGLES2Impl::CoverageModulationCHROMIUM(GLenum components) {
    MojoGLES2MakeCurrent(context_);
    glCoverageModulationCHROMIUM(components);
  }
  GLenum MojoGLES2Impl::GetGraphicsResetStatusKHR() {
    MojoGLES2MakeCurrent(context_);
    return glGetGraphicsResetStatusKHR();
  }
  void MojoGLES2Impl::BlendBarrierKHR() {
    MojoGLES2MakeCurrent(context_);
    glBlendBarrierKHR();
  }
  void MojoGLES2Impl::ApplyScreenSpaceAntialiasingCHROMIUM() {
    MojoGLES2MakeCurrent(context_);
    glApplyScreenSpaceAntialiasingCHROMIUM();
  }
  void MojoGLES2Impl::BindFragDataLocationIndexedEXT(GLuint program,
                                                     GLuint colorNumber,
                                                     GLuint index,
                                                     const char* name) {
    MojoGLES2MakeCurrent(context_);
    glBindFragDataLocationIndexedEXT(program, colorNumber, index, name);
  }
  void MojoGLES2Impl::BindFragDataLocationEXT(GLuint program,
                                              GLuint colorNumber,
                                              const char* name) {
    MojoGLES2MakeCurrent(context_);
    glBindFragDataLocationEXT(program, colorNumber, name);
  }
  GLint MojoGLES2Impl::GetFragDataIndexEXT(GLuint program, const char* name) {
    MojoGLES2MakeCurrent(context_);
    return glGetFragDataIndexEXT(program, name);
  }
  void MojoGLES2Impl::UniformMatrix4fvStreamTextureMatrixCHROMIUM(
      GLint location,
      GLboolean transpose,
      const GLfloat* default_value) {
    MojoGLES2MakeCurrent(context_);
    glUniformMatrix4fvStreamTextureMatrixCHROMIUM(location, transpose,
                                                  default_value);
  }
  
  }  // namespace mojo
  