Mojo container example for hosting Pepper plugins

mojo/examples/pepper_container_app/ppb_opengles2_thunk.cc

-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// 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 "base/logging.h"
+#include "mojo/examples/pepper_container_app/graphics_3d_resource.h"
+#include "mojo/examples/pepper_container_app/thunk.h"
+#include "mojo/public/gles2/gles2.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_graphics_3d_api.h"
 
-#include "ppapi/shared_impl/ppb_opengles2_shared.h"
-
-#include "base/logging.h"
-#include "gpu/command_buffer/client/gles2_implementation.h"
-#include "ppapi/shared_impl/ppb_graphics_3d_shared.h"
-#include "ppapi/thunk/enter.h"
-
-namespace ppapi {
+namespace mojo {
+namespace examples {
 
 namespace {
 
-typedef thunk::EnterResource<thunk::PPB_Graphics3D_API> Enter3D;
+typedef ppapi::thunk::EnterResource<ppapi::thunk::PPB_Graphics3D_API> Enter3D;
 
-gpu::gles2::GLES2Implementation* ToGles2Impl(Enter3D* enter) {
-  DCHECK(enter);
-  DCHECK(enter->succeeded());
-  return static_cast<PPB_Graphics3D_Shared*>(enter->object())->gles2_impl();
+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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->ActiveTexture(texture);
+  if (IsBoundGraphics(&enter)) {
+    glActiveTexture(texture);
   }
 }
 
 void AttachShader(PP_Resource context_id, GLuint program, GLuint shader) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->AttachShader(program, shader);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->BindAttribLocation(program, index, name);
+  if (IsBoundGraphics(&enter)) {
+    glBindAttribLocation(program, index, name);
   }
 }
 
 void BindBuffer(PP_Resource context_id, GLenum target, GLuint buffer) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BindBuffer(target, buffer);
+  if (IsBoundGraphics(&enter)) {
+    glBindBuffer(target, buffer);
   }
 }
 
 void BindFramebuffer(PP_Resource context_id,
                      GLenum target,
                      GLuint framebuffer) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BindFramebuffer(target, framebuffer);
+  if (IsBoundGraphics(&enter)) {
+    glBindFramebuffer(target, framebuffer);
   }
 }
 
 void BindRenderbuffer(PP_Resource context_id,
                       GLenum target,
                       GLuint renderbuffer) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BindRenderbuffer(target, renderbuffer);
+  if (IsBoundGraphics(&enter)) {
+    glBindRenderbuffer(target, renderbuffer);
   }
 }
 
 void BindTexture(PP_Resource context_id, GLenum target, GLuint texture) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BindTexture(target, texture);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->BlendColor(red, green, blue, alpha);
+  if (IsBoundGraphics(&enter)) {
+    glBlendColor(red, green, blue, alpha);
   }
 }
 
 void BlendEquation(PP_Resource context_id, GLenum mode) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BlendEquation(mode);
+  if (IsBoundGraphics(&enter)) {
+    glBlendEquation(mode);
   }
 }
 
 void BlendEquationSeparate(PP_Resource context_id,
                            GLenum modeRGB,
                            GLenum modeAlpha) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BlendEquationSeparate(modeRGB, modeAlpha);
+  if (IsBoundGraphics(&enter)) {
+    glBlendEquationSeparate(modeRGB, modeAlpha);
   }
 }
 
 void BlendFunc(PP_Resource context_id, GLenum sfactor, GLenum dfactor) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BlendFunc(sfactor, dfactor);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->BufferData(target, size, data, usage);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->BufferSubData(target, offset, size, data);
+  if (IsBoundGraphics(&enter)) {
+    glBufferSubData(target, offset, size, data);
   }
 }
 
 GLenum CheckFramebufferStatus(PP_Resource context_id, GLenum target) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->CheckFramebufferStatus(target);
+  if (IsBoundGraphics(&enter)) {
+    return glCheckFramebufferStatus(target);
   } else {
     return 0;
   }
 }
 
 void Clear(PP_Resource context_id, GLbitfield mask) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->Clear(mask);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->ClearColor(red, green, blue, alpha);
+  if (IsBoundGraphics(&enter)) {
+    glClearColor(red, green, blue, alpha);
   }
 }
 
 void ClearDepthf(PP_Resource context_id, GLclampf depth) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->ClearDepthf(depth);
+  if (IsBoundGraphics(&enter)) {
+    glClearDepthf(depth);
   }
 }
 
 void ClearStencil(PP_Resource context_id, GLint s) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->ClearStencil(s);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->ColorMask(red, green, blue, alpha);
+  if (IsBoundGraphics(&enter)) {
+    glColorMask(red, green, blue, alpha);
   }
 }
 
 void CompileShader(PP_Resource context_id, GLuint shader) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->CompileShader(shader);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->CompressedTexImage2D(
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->CompressedTexSubImage2D(target,
-                                                 level,
-                                                 xoffset,
-                                                 yoffset,
-                                                 width,
-                                                 height,
-                                                 format,
-                                                 imageSize,
-                                                 data);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->CopyTexImage2D(
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->CopyTexSubImage2D(
-        target, level, xoffset, yoffset, x, y, width, height);
+  if (IsBoundGraphics(&enter)) {
+    glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
   }
 }
 
 GLuint CreateProgram(PP_Resource context_id) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->CreateProgram();
+  if (IsBoundGraphics(&enter)) {
+    return glCreateProgram();
   } else {
     return 0;
   }
 }
 
 GLuint CreateShader(PP_Resource context_id, GLenum type) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->CreateShader(type);
+  if (IsBoundGraphics(&enter)) {
+    return glCreateShader(type);
   } else {
     return 0;
   }
 }
 
 void CullFace(PP_Resource context_id, GLenum mode) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->CullFace(mode);
+  if (IsBoundGraphics(&enter)) {
+    glCullFace(mode);
   }
 }
 
 void DeleteBuffers(PP_Resource context_id, GLsizei n, const GLuint* buffers) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DeleteBuffers(n, buffers);
+  if (IsBoundGraphics(&enter)) {
+    glDeleteBuffers(n, buffers);
   }
 }
 
 void DeleteFramebuffers(PP_Resource context_id,
                         GLsizei n,
                         const GLuint* framebuffers) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DeleteFramebuffers(n, framebuffers);
+  if (IsBoundGraphics(&enter)) {
+    glDeleteFramebuffers(n, framebuffers);
   }
 }
 
 void DeleteProgram(PP_Resource context_id, GLuint program) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DeleteProgram(program);
+  if (IsBoundGraphics(&enter)) {
+    glDeleteProgram(program);
   }
 }
 
 void DeleteRenderbuffers(PP_Resource context_id,
                          GLsizei n,
                          const GLuint* renderbuffers) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DeleteRenderbuffers(n, renderbuffers);
+  if (IsBoundGraphics(&enter)) {
+    glDeleteRenderbuffers(n, renderbuffers);
   }
 }
 
 void DeleteShader(PP_Resource context_id, GLuint shader) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DeleteShader(shader);
+  if (IsBoundGraphics(&enter)) {
+    glDeleteShader(shader);
   }
 }
 
 void DeleteTextures(PP_Resource context_id, GLsizei n, const GLuint* textures) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DeleteTextures(n, textures);
+  if (IsBoundGraphics(&enter)) {
+    glDeleteTextures(n, textures);
   }
 }
 
 void DepthFunc(PP_Resource context_id, GLenum func) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DepthFunc(func);
+  if (IsBoundGraphics(&enter)) {
+    glDepthFunc(func);
   }
 }
 
 void DepthMask(PP_Resource context_id, GLboolean flag) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DepthMask(flag);
+  if (IsBoundGraphics(&enter)) {
+    glDepthMask(flag);
   }
 }
 
 void DepthRangef(PP_Resource context_id, GLclampf zNear, GLclampf zFar) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DepthRangef(zNear, zFar);
+  if (IsBoundGraphics(&enter)) {
+    glDepthRangef(zNear, zFar);
   }
 }
 
 void DetachShader(PP_Resource context_id, GLuint program, GLuint shader) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DetachShader(program, shader);
+  if (IsBoundGraphics(&enter)) {
+    glDetachShader(program, shader);
   }
 }
 
 void Disable(PP_Resource context_id, GLenum cap) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->Disable(cap);
+  if (IsBoundGraphics(&enter)) {
+    glDisable(cap);
   }
 }
 
 void DisableVertexAttribArray(PP_Resource context_id, GLuint index) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DisableVertexAttribArray(index);
+  if (IsBoundGraphics(&enter)) {
+    glDisableVertexAttribArray(index);
   }
 }
 
 void DrawArrays(PP_Resource context_id,
                 GLenum mode,
                 GLint first,
                 GLsizei count) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DrawArrays(mode, first, count);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->DrawElements(mode, count, type, indices);
+  if (IsBoundGraphics(&enter)) {
+    glDrawElements(mode, count, type, indices);
   }
 }
 
 void Enable(PP_Resource context_id, GLenum cap) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->Enable(cap);
+  if (IsBoundGraphics(&enter)) {
+    glEnable(cap);
   }
 }
 
 void EnableVertexAttribArray(PP_Resource context_id, GLuint index) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->EnableVertexAttribArray(index);
+  if (IsBoundGraphics(&enter)) {
+    glEnableVertexAttribArray(index);
   }
 }
 
 void Finish(PP_Resource context_id) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->Finish();
+  if (IsBoundGraphics(&enter)) {
+    glFinish();
   }
 }
 
 void Flush(PP_Resource context_id) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->Flush();
+  if (IsBoundGraphics(&enter)) {
+    glFlush();
   }
 }
 
 void FramebufferRenderbuffer(PP_Resource context_id,
                              GLenum target,
                              GLenum attachment,
                              GLenum renderbuffertarget,
                              GLuint renderbuffer) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->FramebufferRenderbuffer(
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)
-        ->FramebufferTexture2D(target, attachment, textarget, texture, level);
+  if (IsBoundGraphics(&enter)) {
+    glFramebufferTexture2D(target, attachment, textarget, texture, level);
   }
 }
 
 void FrontFace(PP_Resource context_id, GLenum mode) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->FrontFace(mode);
+  if (IsBoundGraphics(&enter)) {
+    glFrontFace(mode);
   }
 }
 
 void GenBuffers(PP_Resource context_id, GLsizei n, GLuint* buffers) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GenBuffers(n, buffers);
+  if (IsBoundGraphics(&enter)) {
+    glGenBuffers(n, buffers);
   }
 }
 
 void GenerateMipmap(PP_Resource context_id, GLenum target) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GenerateMipmap(target);
+  if (IsBoundGraphics(&enter)) {
+    glGenerateMipmap(target);
   }
 }
 
 void GenFramebuffers(PP_Resource context_id, GLsizei n, GLuint* framebuffers) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GenFramebuffers(n, framebuffers);
+  if (IsBoundGraphics(&enter)) {
+    glGenFramebuffers(n, framebuffers);
   }
 }
 
 void GenRenderbuffers(PP_Resource context_id,
                       GLsizei n,
                       GLuint* renderbuffers) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GenRenderbuffers(n, renderbuffers);
+  if (IsBoundGraphics(&enter)) {
+    glGenRenderbuffers(n, renderbuffers);
   }
 }
 
 void GenTextures(PP_Resource context_id, GLsizei n, GLuint* textures) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GenTextures(n, textures);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)
-        ->GetActiveAttrib(program, index, bufsize, length, size, type, name);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)
-        ->GetActiveUniform(program, index, bufsize, length, size, type, name);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetAttachedShaders(program, maxcount, count, shaders);
+  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 (enter.succeeded()) {
-    return ToGles2Impl(&enter)->GetAttribLocation(program, name);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetBooleanv(pname, params);
+  if (IsBoundGraphics(&enter)) {
+    glGetBooleanv(pname, params);
   }
 }
 
 void GetBufferParameteriv(PP_Resource context_id,
                           GLenum target,
                           GLenum pname,
                           GLint* params) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetBufferParameteriv(target, pname, params);
+  if (IsBoundGraphics(&enter)) {
+    glGetBufferParameteriv(target, pname, params);
   }
 }
 
 GLenum GetError(PP_Resource context_id) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->GetError();
+  if (IsBoundGraphics(&enter)) {
+    return glGetError();
   } else {
     return 0;
   }
 }
 
 void GetFloatv(PP_Resource context_id, GLenum pname, GLfloat* params) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetFloatv(pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetFramebufferAttachmentParameteriv(
-        target, attachment, pname, params);
+  if (IsBoundGraphics(&enter)) {
+    glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
   }
 }
 
 void GetIntegerv(PP_Resource context_id, GLenum pname, GLint* params) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetIntegerv(pname, params);
+  if (IsBoundGraphics(&enter)) {
+    glGetIntegerv(pname, params);
   }
 }
 
 void GetProgramiv(PP_Resource context_id,
                   GLuint program,
                   GLenum pname,
                   GLint* params) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetProgramiv(program, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetProgramInfoLog(program, bufsize, length, infolog);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetRenderbufferParameteriv(target, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetShaderiv(shader, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetShaderInfoLog(shader, bufsize, length, infolog);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)
-        ->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetShaderSource(shader, bufsize, length, source);
+  if (IsBoundGraphics(&enter)) {
+    glGetShaderSource(shader, bufsize, length, source);
   }
 }
 
 const GLubyte* GetString(PP_Resource context_id, GLenum name) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->GetString(name);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetTexParameterfv(target, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetTexParameteriv(target, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetUniformfv(program, location, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetUniformiv(program, location, params);
+  if (IsBoundGraphics(&enter)) {
+    glGetUniformiv(program, location, params);
   }
 }
 
 GLint GetUniformLocation(PP_Resource context_id,
                          GLuint program,
                          const char* name) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->GetUniformLocation(program, name);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetVertexAttribfv(index, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetVertexAttribiv(index, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetVertexAttribPointerv(index, pname, pointer);
+  if (IsBoundGraphics(&enter)) {
+    glGetVertexAttribPointerv(index, pname, pointer);
   }
 }
 
 void Hint(PP_Resource context_id, GLenum target, GLenum mode) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->Hint(target, mode);
+  if (IsBoundGraphics(&enter)) {
+    glHint(target, mode);
   }
 }
 
 GLboolean IsBuffer(PP_Resource context_id, GLuint buffer) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->IsBuffer(buffer);
+  if (IsBoundGraphics(&enter)) {
+    return glIsBuffer(buffer);
   } else {
     return GL_FALSE;
   }
 }
 
 GLboolean IsEnabled(PP_Resource context_id, GLenum cap) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->IsEnabled(cap);
+  if (IsBoundGraphics(&enter)) {
+    return glIsEnabled(cap);
   } else {
     return GL_FALSE;
   }
 }
 
 GLboolean IsFramebuffer(PP_Resource context_id, GLuint framebuffer) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->IsFramebuffer(framebuffer);
+  if (IsBoundGraphics(&enter)) {
+    return glIsFramebuffer(framebuffer);
   } else {
     return GL_FALSE;
   }
 }
 
 GLboolean IsProgram(PP_Resource context_id, GLuint program) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->IsProgram(program);
+  if (IsBoundGraphics(&enter)) {
+    return glIsProgram(program);
   } else {
     return GL_FALSE;
   }
 }
 
 GLboolean IsRenderbuffer(PP_Resource context_id, GLuint renderbuffer) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->IsRenderbuffer(renderbuffer);
+  if (IsBoundGraphics(&enter)) {
+    return glIsRenderbuffer(renderbuffer);
   } else {
     return GL_FALSE;
   }
 }
 
 GLboolean IsShader(PP_Resource context_id, GLuint shader) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->IsShader(shader);
+  if (IsBoundGraphics(&enter)) {
+    return glIsShader(shader);
   } else {
     return GL_FALSE;
   }
 }
 
 GLboolean IsTexture(PP_Resource context_id, GLuint texture) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->IsTexture(texture);
+  if (IsBoundGraphics(&enter)) {
+    return glIsTexture(texture);
   } else {
     return GL_FALSE;
   }
 }
 
 void LineWidth(PP_Resource context_id, GLfloat width) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->LineWidth(width);
+  if (IsBoundGraphics(&enter)) {
+    glLineWidth(width);
   }
 }
 
 void LinkProgram(PP_Resource context_id, GLuint program) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->LinkProgram(program);
+  if (IsBoundGraphics(&enter)) {
+    glLinkProgram(program);
   }
 }
 
 void PixelStorei(PP_Resource context_id, GLenum pname, GLint param) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->PixelStorei(pname, param);
+  if (IsBoundGraphics(&enter)) {
+    glPixelStorei(pname, param);
   }
 }
 
 void PolygonOffset(PP_Resource context_id, GLfloat factor, GLfloat units) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->PolygonOffset(factor, units);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->ReadPixels(x, y, width, height, format, type, pixels);
+  if (IsBoundGraphics(&enter)) {
+    glReadPixels(x, y, width, height, format, type, pixels);
   }
 }
 
 void ReleaseShaderCompiler(PP_Resource context_id) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->ReleaseShaderCompiler();
+  if (IsBoundGraphics(&enter)) {
+    glReleaseShaderCompiler();
   }
 }
 
 void RenderbufferStorage(PP_Resource context_id,
                          GLenum target,
                          GLenum internalformat,
                          GLsizei width,
                          GLsizei height) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)
-        ->RenderbufferStorage(target, internalformat, width, height);
+  if (IsBoundGraphics(&enter)) {
+    glRenderbufferStorage(target, internalformat, width, height);
   }
 }
 
 void SampleCoverage(PP_Resource context_id, GLclampf value, GLboolean invert) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->SampleCoverage(value, invert);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Scissor(x, y, width, height);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->ShaderBinary(n, shaders, binaryformat, binary, length);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->ShaderSource(shader, count, str, length);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->StencilFunc(func, ref, mask);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->StencilFuncSeparate(face, func, ref, mask);
+  if (IsBoundGraphics(&enter)) {
+    glStencilFuncSeparate(face, func, ref, mask);
   }
 }
 
 void StencilMask(PP_Resource context_id, GLuint mask) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->StencilMask(mask);
+  if (IsBoundGraphics(&enter)) {
+    glStencilMask(mask);
   }
 }
 
 void StencilMaskSeparate(PP_Resource context_id, GLenum face, GLuint mask) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->StencilMaskSeparate(face, mask);
+  if (IsBoundGraphics(&enter)) {
+    glStencilMaskSeparate(face, mask);
   }
 }
 
 void StencilOp(PP_Resource context_id,
                GLenum fail,
                GLenum zfail,
                GLenum zpass) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->StencilOp(fail, zfail, zpass);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->StencilOpSeparate(face, fail, zfail, zpass);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->TexImage2D(target,
-                                    level,
-                                    internalformat,
-                                    width,
-                                    height,
-                                    border,
-                                    format,
-                                    type,
-                                    pixels);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->TexParameterf(target, pname, param);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->TexParameterfv(target, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->TexParameteri(target, pname, param);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->TexParameteriv(target, pname, params);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->TexSubImage2D(
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform1f(location, x);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform1fv(location, count, v);
+  if (IsBoundGraphics(&enter)) {
+    glUniform1fv(location, count, v);
   }
 }
 
 void Uniform1i(PP_Resource context_id, GLint location, GLint x) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform1i(location, x);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform1iv(location, count, v);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform2f(location, x, y);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform2fv(location, count, v);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform2i(location, x, y);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform2iv(location, count, v);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform3f(location, x, y, z);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform3fv(location, count, v);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform3i(location, x, y, z);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform3iv(location, count, v);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform4f(location, x, y, z, w);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform4fv(location, count, v);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform4i(location, x, y, z, w);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Uniform4iv(location, count, v);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->UniformMatrix2fv(location, count, transpose, value);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->UniformMatrix3fv(location, count, transpose, value);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->UniformMatrix4fv(location, count, transpose, value);
+  if (IsBoundGraphics(&enter)) {
+    glUniformMatrix4fv(location, count, transpose, value);
   }
 }
 
 void UseProgram(PP_Resource context_id, GLuint program) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->UseProgram(program);
+  if (IsBoundGraphics(&enter)) {
+    glUseProgram(program);
   }
 }
 
 void ValidateProgram(PP_Resource context_id, GLuint program) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->ValidateProgram(program);
+  if (IsBoundGraphics(&enter)) {
+    glValidateProgram(program);
   }
 }
 
 void VertexAttrib1f(PP_Resource context_id, GLuint indx, GLfloat x) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttrib1f(indx, x);
+  if (IsBoundGraphics(&enter)) {
+    glVertexAttrib1f(indx, x);
   }
 }
 
 void VertexAttrib1fv(PP_Resource context_id,
                      GLuint indx,
                      const GLfloat* values) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttrib1fv(indx, values);
+  if (IsBoundGraphics(&enter)) {
+    glVertexAttrib1fv(indx, values);
   }
 }
 
 void VertexAttrib2f(PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttrib2f(indx, x, y);
+  if (IsBoundGraphics(&enter)) {
+    glVertexAttrib2f(indx, x, y);
   }
 }
 
 void VertexAttrib2fv(PP_Resource context_id,
                      GLuint indx,
                      const GLfloat* values) {
   Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttrib2fv(indx, values);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttrib3f(indx, x, y, z);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttrib3fv(indx, values);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttrib4f(indx, x, y, z, w);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttrib4fv(indx, values);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)
-        ->VertexAttribPointer(indx, size, type, normalized, stride, ptr);
+  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 (enter.succeeded()) {
-    ToGles2Impl(&enter)->Viewport(x, y, width, height);
-  }
-}
-
-void BlitFramebufferEXT(PP_Resource context_id,
-                        GLint srcX0,
-                        GLint srcY0,
-                        GLint srcX1,
-                        GLint srcY1,
-                        GLint dstX0,
-                        GLint dstY0,
-                        GLint dstX1,
-                        GLint dstY1,
-                        GLbitfield mask,
-                        GLenum filter) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BlitFramebufferCHROMIUM(
-        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-  }
-}
-
-void RenderbufferStorageMultisampleEXT(PP_Resource context_id,
-                                       GLenum target,
-                                       GLsizei samples,
-                                       GLenum internalformat,
-                                       GLsizei width,
-                                       GLsizei height) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->RenderbufferStorageMultisampleCHROMIUM(
-        target, samples, internalformat, width, height);
-  }
-}
-
-void GenQueriesEXT(PP_Resource context_id, GLsizei n, GLuint* queries) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GenQueriesEXT(n, queries);
-  }
-}
-
-void DeleteQueriesEXT(PP_Resource context_id,
-                      GLsizei n,
-                      const GLuint* queries) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DeleteQueriesEXT(n, queries);
-  }
-}
-
-GLboolean IsQueryEXT(PP_Resource context_id, GLuint id) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->IsQueryEXT(id);
-  } else {
-    return GL_FALSE;
-  }
-}
-
-void BeginQueryEXT(PP_Resource context_id, GLenum target, GLuint id) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->BeginQueryEXT(target, id);
-  }
-}
-
-void EndQueryEXT(PP_Resource context_id, GLenum target) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->EndQueryEXT(target);
-  }
-}
-
-void GetQueryivEXT(PP_Resource context_id,
-                   GLenum target,
-                   GLenum pname,
-                   GLint* params) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetQueryivEXT(target, pname, params);
-  }
-}
-
-void GetQueryObjectuivEXT(PP_Resource context_id,
-                          GLuint id,
-                          GLenum pname,
-                          GLuint* params) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->GetQueryObjectuivEXT(id, pname, params);
-  }
-}
-
-GLboolean EnableFeatureCHROMIUM(PP_Resource context_id, const char* feature) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->EnableFeatureCHROMIUM(feature);
-  } else {
-    return GL_FALSE;
-  }
-}
-
-void* MapBufferSubDataCHROMIUM(PP_Resource context_id,
-                               GLuint target,
-                               GLintptr offset,
-                               GLsizeiptr size,
-                               GLenum access) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)
-        ->MapBufferSubDataCHROMIUM(target, offset, size, access);
-  } else {
-    return NULL;
-  }
-}
-
-void UnmapBufferSubDataCHROMIUM(PP_Resource context_id, const void* mem) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->UnmapBufferSubDataCHROMIUM(mem);
-  }
-}
-
-void* MapTexSubImage2DCHROMIUM(PP_Resource context_id,
-                               GLenum target,
-                               GLint level,
-                               GLint xoffset,
-                               GLint yoffset,
-                               GLsizei width,
-                               GLsizei height,
-                               GLenum format,
-                               GLenum type,
-                               GLenum access) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    return ToGles2Impl(&enter)->MapTexSubImage2DCHROMIUM(
-        target, level, xoffset, yoffset, width, height, format, type, access);
-  } else {
-    return NULL;
-  }
-}
-
-void UnmapTexSubImage2DCHROMIUM(PP_Resource context_id, const void* mem) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->UnmapTexSubImage2DCHROMIUM(mem);
-  }
-}
-
-void DrawArraysInstancedANGLE(PP_Resource context_id,
-                              GLenum mode,
-                              GLint first,
-                              GLsizei count,
-                              GLsizei primcount) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)
-        ->DrawArraysInstancedANGLE(mode, first, count, primcount);
-  }
-}
-
-void DrawElementsInstancedANGLE(PP_Resource context_id,
-                                GLenum mode,
-                                GLsizei count,
-                                GLenum type,
-                                const void* indices,
-                                GLsizei primcount) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)
-        ->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
-  }
-}
-
-void VertexAttribDivisorANGLE(PP_Resource context_id,
-                              GLuint index,
-                              GLuint divisor) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->VertexAttribDivisorANGLE(index, divisor);
-  }
-}
-
-void DrawBuffersEXT(PP_Resource context_id, GLsizei count, const GLenum* bufs) {
-  Enter3D enter(context_id, true);
-  if (enter.succeeded()) {
-    ToGles2Impl(&enter)->DrawBuffersEXT(count, bufs);
+  if (IsBoundGraphics(&enter)) {
+    glViewport(x, y, width, height);
   }
 }
 
 }  // namespace
-const PPB_OpenGLES2* PPB_OpenGLES2_Shared::GetInterface() {
+
+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,
@@ skipping 54 matching lines @@
       &Uniform4iv,                          &UniformMatrix2fv,
       &UniformMatrix3fv,                    &UniformMatrix4fv,
       &UseProgram,                          &ValidateProgram,
       &VertexAttrib1f,                      &VertexAttrib1fv,
       &VertexAttrib2f,                      &VertexAttrib2fv,
       &VertexAttrib3f,                      &VertexAttrib3fv,
       &VertexAttrib4f,                      &VertexAttrib4fv,
       &VertexAttribPointer,                 &Viewport};
   return &ppb_opengles2;
 }
-const PPB_OpenGLES2InstancedArrays*
-PPB_OpenGLES2_Shared::GetInstancedArraysInterface() {
-  static const struct PPB_OpenGLES2InstancedArrays ppb_opengles2 = {
-      &DrawArraysInstancedANGLE, &DrawElementsInstancedANGLE,
-      &VertexAttribDivisorANGLE};
-  return &ppb_opengles2;
-}
-const PPB_OpenGLES2FramebufferBlit*
-PPB_OpenGLES2_Shared::GetFramebufferBlitInterface() {
-  static const struct PPB_OpenGLES2FramebufferBlit ppb_opengles2 = {
-      &BlitFramebufferEXT};
-  return &ppb_opengles2;
-}
-const PPB_OpenGLES2FramebufferMultisample*
-PPB_OpenGLES2_Shared::GetFramebufferMultisampleInterface() {
-  static const struct PPB_OpenGLES2FramebufferMultisample ppb_opengles2 = {
-      &RenderbufferStorageMultisampleEXT};
-  return &ppb_opengles2;
-}
-const PPB_OpenGLES2ChromiumEnableFeature*
-PPB_OpenGLES2_Shared::GetChromiumEnableFeatureInterface() {
-  static const struct PPB_OpenGLES2ChromiumEnableFeature ppb_opengles2 = {
-      &EnableFeatureCHROMIUM};
-  return &ppb_opengles2;
-}
-const PPB_OpenGLES2ChromiumMapSub*
-PPB_OpenGLES2_Shared::GetChromiumMapSubInterface() {
-  static const struct PPB_OpenGLES2ChromiumMapSub ppb_opengles2 = {
-      &MapBufferSubDataCHROMIUM, &UnmapBufferSubDataCHROMIUM,
-      &MapTexSubImage2DCHROMIUM, &UnmapTexSubImage2DCHROMIUM};
-  return &ppb_opengles2;
-}
-const PPB_OpenGLES2Query* PPB_OpenGLES2_Shared::GetQueryInterface() {
-  static const struct PPB_OpenGLES2Query ppb_opengles2 = {
-      &GenQueriesEXT, &DeleteQueriesEXT, &IsQueryEXT,          &BeginQueryEXT,
-      &EndQueryEXT,   &GetQueryivEXT,    &GetQueryObjectuivEXT};
-  return &ppb_opengles2;
-}
-const PPB_OpenGLES2DrawBuffers_Dev*
-PPB_OpenGLES2_Shared::GetDrawBuffersInterface() {
-  static const struct PPB_OpenGLES2DrawBuffers_Dev ppb_opengles2 = {
-      &DrawBuffersEXT};
-  return &ppb_opengles2;
-}
-}  // namespace ppapi
+
+}  // namespace examples
+}  // namespace mojo