Convert most remaining resources to use the API/thunk system. The significant

ppapi/proxy/ppb_opengles2_proxy.cc

Index: ppapi/proxy/ppb_opengles2_proxy.cc
===================================================================
--- ppapi/proxy/ppb_opengles2_proxy.cc	(revision 89610)
+++ ppapi/proxy/ppb_opengles2_proxy.cc	(working copy)
@@ -13,139 +13,126 @@
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppb_context_3d_proxy.h"
+#include "ppapi/shared_impl/resource_object_base.h"

[alokp, 2011/06/20 16:36:03]

This file is supposed to be auto-generated. Not a problem if you hand edited it,
I can change the script in subsequent CL to generate this output.

[brettw, 2011/06/20 19:31:03]

I searched for a while and couldn't find the original anywhere. Where is it? Can
the generated output list how it was generated?

[alokp, 2011/06/20 19:50:46]

It is generated using gpu/command_buffer/build_gles2_cmd_buffer.py. Sorry the
script has become messy with all the new functionality for ppapi. It is on my
TODO list to separate out the ppapi stuff.

+#include "ppapi/shared_impl/tracker_base.h"
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
+gpu::gles2::GLES2Implementation* GetGLES(PP_Resource context) {
+  ppapi::ResourceObjectBase* base =
+      ppapi::TrackerBase::Get()->GetResourceAPI(context);
+  DCHECK(base->AsPPB_Context3D_API());
+  return static_cast<Context3D*>(base)->gles2_impl();
+}
+
 void ActiveTexture(PP_Resource context_id, GLenum texture) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ActiveTexture(texture);
+  GetGLES(context_id)->ActiveTexture(texture);
 }
 
 void AttachShader(PP_Resource context_id, GLuint program, GLuint shader) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->AttachShader(program, shader);
+  GetGLES(context_id)->AttachShader(program, shader);
 }
 
 void BindAttribLocation(
     PP_Resource context_id, GLuint program, GLuint index, const char* name) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BindAttribLocation(program, index, name);
+  GetGLES(context_id)->BindAttribLocation(program, index, name);
 }
 
 void BindBuffer(PP_Resource context_id, GLenum target, GLuint buffer) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BindBuffer(target, buffer);
+  GetGLES(context_id)->BindBuffer(target, buffer);
 }
 
 void BindFramebuffer(
     PP_Resource context_id, GLenum target, GLuint framebuffer) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BindFramebuffer(target, framebuffer);
+  GetGLES(context_id)->BindFramebuffer(target, framebuffer);
 }
 
 void BindRenderbuffer(
     PP_Resource context_id, GLenum target, GLuint renderbuffer) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BindRenderbuffer(target, renderbuffer);
+  GetGLES(context_id)->BindRenderbuffer(target, renderbuffer);
 }
 
 void BindTexture(PP_Resource context_id, GLenum target, GLuint texture) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BindTexture(target, texture);
+  GetGLES(context_id)->BindTexture(target, texture);
 }
 
 void BlendColor(
     PP_Resource context_id, GLclampf red, GLclampf green, GLclampf blue,
     GLclampf alpha) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BlendColor(red, green, blue, alpha);
+  GetGLES(context_id)->BlendColor(red, green, blue, alpha);
 }
 
 void BlendEquation(PP_Resource context_id, GLenum mode) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BlendEquation(mode);
+  GetGLES(context_id)->BlendEquation(mode);
 }
 
 void BlendEquationSeparate(
     PP_Resource context_id, GLenum modeRGB, GLenum modeAlpha) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BlendEquationSeparate(modeRGB, modeAlpha);
+  GetGLES(context_id)->BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 void BlendFunc(PP_Resource context_id, GLenum sfactor, GLenum dfactor) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BlendFunc(sfactor, dfactor);
+  GetGLES(context_id)->BlendFunc(sfactor, dfactor);
 }
 
 void BlendFuncSeparate(
     PP_Resource context_id, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
     GLenum dstAlpha) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+  GetGLES(context_id)->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 void BufferData(
     PP_Resource context_id, GLenum target, GLsizeiptr size, const void* data,
     GLenum usage) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BufferData(target, size, data, usage);
+  GetGLES(context_id)->BufferData(target, size, data, usage);
 }
 
 void BufferSubData(
     PP_Resource context_id, GLenum target, GLintptr offset, GLsizeiptr size,
     const void* data) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->BufferSubData(target, offset, size, data);
+  GetGLES(context_id)->BufferSubData(target, offset, size, data);
 }
 
 GLenum CheckFramebufferStatus(PP_Resource context_id, GLenum target) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->CheckFramebufferStatus(target);
+  return GetGLES(context_id)->CheckFramebufferStatus(target);
 }
 
 void Clear(PP_Resource context_id, GLbitfield mask) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Clear(mask);
+  GetGLES(context_id)->Clear(mask);
 }
 
 void ClearColor(
     PP_Resource context_id, GLclampf red, GLclampf green, GLclampf blue,
     GLclampf alpha) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ClearColor(red, green, blue, alpha);
+  GetGLES(context_id)->ClearColor(red, green, blue, alpha);
 }
 
 void ClearDepthf(PP_Resource context_id, GLclampf depth) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ClearDepthf(depth);
+  GetGLES(context_id)->ClearDepthf(depth);
 }
 
 void ClearStencil(PP_Resource context_id, GLint s) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ClearStencil(s);
+  GetGLES(context_id)->ClearStencil(s);
 }
 
 void ColorMask(
     PP_Resource context_id, GLboolean red, GLboolean green, GLboolean blue,
     GLboolean alpha) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ColorMask(red, green, blue, alpha);
+  GetGLES(context_id)->ColorMask(red, green, blue, alpha);
 }
 
 void CompileShader(PP_Resource context_id, GLuint shader) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->CompileShader(shader);
+  GetGLES(context_id)->CompileShader(shader);
 }
 
 void CompressedTexImage2D(
     PP_Resource context_id, GLenum target, GLint level, GLenum internalformat,
     GLsizei width, GLsizei height, GLint border, GLsizei imageSize,
     const void* data) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->CompressedTexImage2D(
+  GetGLES(context_id)->CompressedTexImage2D(
       target, level, internalformat, width, height, border, imageSize, data);
 }
 
@@ -153,717 +140,597 @@
     PP_Resource context_id, GLenum target, GLint level, GLint xoffset,
     GLint yoffset, GLsizei width, GLsizei height, GLenum format,
     GLsizei imageSize, const void* data) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->CompressedTexSubImage2D(
+  GetGLES(context_id)->CompressedTexSubImage2D(
       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) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->CopyTexImage2D(
+  GetGLES(context_id)->CopyTexImage2D(
       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) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->CopyTexSubImage2D(
+  GetGLES(context_id)->CopyTexSubImage2D(
       target, level, xoffset, yoffset, x, y, width, height);
 }
 
 GLuint CreateProgram(PP_Resource context_id) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->CreateProgram();
+  return GetGLES(context_id)->CreateProgram();
 }
 
 GLuint CreateShader(PP_Resource context_id, GLenum type) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->CreateShader(type);
+  return GetGLES(context_id)->CreateShader(type);
 }
 
 void CullFace(PP_Resource context_id, GLenum mode) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->CullFace(mode);
+  GetGLES(context_id)->CullFace(mode);
 }
 
 void DeleteBuffers(PP_Resource context_id, GLsizei n, const GLuint* buffers) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DeleteBuffers(n, buffers);
+  GetGLES(context_id)->DeleteBuffers(n, buffers);
 }
 
 void DeleteFramebuffers(
     PP_Resource context_id, GLsizei n, const GLuint* framebuffers) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DeleteFramebuffers(n, framebuffers);
+  GetGLES(context_id)->DeleteFramebuffers(n, framebuffers);
 }
 
 void DeleteProgram(PP_Resource context_id, GLuint program) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DeleteProgram(program);
+  GetGLES(context_id)->DeleteProgram(program);
 }
 
 void DeleteRenderbuffers(
     PP_Resource context_id, GLsizei n, const GLuint* renderbuffers) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DeleteRenderbuffers(n, renderbuffers);
+  GetGLES(context_id)->DeleteRenderbuffers(n, renderbuffers);
 }
 
 void DeleteShader(PP_Resource context_id, GLuint shader) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DeleteShader(shader);
+  GetGLES(context_id)->DeleteShader(shader);
 }
 
 void DeleteTextures(
     PP_Resource context_id, GLsizei n, const GLuint* textures) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DeleteTextures(n, textures);
+  GetGLES(context_id)->DeleteTextures(n, textures);
 }
 
 void DepthFunc(PP_Resource context_id, GLenum func) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DepthFunc(func);
+  GetGLES(context_id)->DepthFunc(func);
 }
 
 void DepthMask(PP_Resource context_id, GLboolean flag) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DepthMask(flag);
+  GetGLES(context_id)->DepthMask(flag);
 }
 
 void DepthRangef(PP_Resource context_id, GLclampf zNear, GLclampf zFar) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DepthRangef(zNear, zFar);
+  GetGLES(context_id)->DepthRangef(zNear, zFar);
 }
 
 void DetachShader(PP_Resource context_id, GLuint program, GLuint shader) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DetachShader(program, shader);
+  GetGLES(context_id)->DetachShader(program, shader);
 }
 
 void Disable(PP_Resource context_id, GLenum cap) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Disable(cap);
+  GetGLES(context_id)->Disable(cap);
 }
 
 void DisableVertexAttribArray(PP_Resource context_id, GLuint index) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DisableVertexAttribArray(index);
+  GetGLES(context_id)->DisableVertexAttribArray(index);
 }
 
 void DrawArrays(
     PP_Resource context_id, GLenum mode, GLint first, GLsizei count) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DrawArrays(mode, first, count);
+  GetGLES(context_id)->DrawArrays(mode, first, count);
 }
 
 void DrawElements(
     PP_Resource context_id, GLenum mode, GLsizei count, GLenum type,
     const void* indices) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->DrawElements(mode, count, type, indices);
+  GetGLES(context_id)->DrawElements(mode, count, type, indices);
 }
 
 void Enable(PP_Resource context_id, GLenum cap) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Enable(cap);
+  GetGLES(context_id)->Enable(cap);
 }
 
 void EnableVertexAttribArray(PP_Resource context_id, GLuint index) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->EnableVertexAttribArray(index);
+  GetGLES(context_id)->EnableVertexAttribArray(index);
 }
 
 void Finish(PP_Resource context_id) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Finish();
+  GetGLES(context_id)->Finish();
 }
 
 void Flush(PP_Resource context_id) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Flush();
+  GetGLES(context_id)->Flush();
 }
 
 void FramebufferRenderbuffer(
     PP_Resource context_id, GLenum target, GLenum attachment,
     GLenum renderbuffertarget, GLuint renderbuffer) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->FramebufferRenderbuffer(
+  GetGLES(context_id)->FramebufferRenderbuffer(
       target, attachment, renderbuffertarget, renderbuffer);
 }
 
 void FramebufferTexture2D(
     PP_Resource context_id, GLenum target, GLenum attachment, GLenum textarget,
     GLuint texture, GLint level) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->FramebufferTexture2D(
+  GetGLES(context_id)->FramebufferTexture2D(
       target, attachment, textarget, texture, level);
 }
 
 void FrontFace(PP_Resource context_id, GLenum mode) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->FrontFace(mode);
+  GetGLES(context_id)->FrontFace(mode);
 }
 
 void GenBuffers(PP_Resource context_id, GLsizei n, GLuint* buffers) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GenBuffers(n, buffers);
+  GetGLES(context_id)->GenBuffers(n, buffers);
 }
 
 void GenerateMipmap(PP_Resource context_id, GLenum target) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GenerateMipmap(target);
+  GetGLES(context_id)->GenerateMipmap(target);
 }
 
 void GenFramebuffers(PP_Resource context_id, GLsizei n, GLuint* framebuffers) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GenFramebuffers(n, framebuffers);
+  GetGLES(context_id)->GenFramebuffers(n, framebuffers);
 }
 
 void GenRenderbuffers(
     PP_Resource context_id, GLsizei n, GLuint* renderbuffers) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GenRenderbuffers(n, renderbuffers);
+  GetGLES(context_id)->GenRenderbuffers(n, renderbuffers);
 }
 
 void GenTextures(PP_Resource context_id, GLsizei n, GLuint* textures) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GenTextures(n, textures);
+  GetGLES(context_id)->GenTextures(n, textures);
 }
 
 void GetActiveAttrib(
     PP_Resource context_id, GLuint program, GLuint index, GLsizei bufsize,
     GLsizei* length, GLint* size, GLenum* type, char* name) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetActiveAttrib(
+  GetGLES(context_id)->GetActiveAttrib(
       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) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetActiveUniform(
+  GetGLES(context_id)->GetActiveUniform(
       program, index, bufsize, length, size, type, name);
 }
 
 void GetAttachedShaders(
     PP_Resource context_id, GLuint program, GLsizei maxcount, GLsizei* count,
     GLuint* shaders) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetAttachedShaders(program, maxcount, count, shaders);
+  GetGLES(context_id)->GetAttachedShaders(program, maxcount, count, shaders);
 }
 
 GLint GetAttribLocation(
     PP_Resource context_id, GLuint program, const char* name) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->GetAttribLocation(program, name);
+  return GetGLES(context_id)->GetAttribLocation(program, name);
 }
 
 void GetBooleanv(PP_Resource context_id, GLenum pname, GLboolean* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetBooleanv(pname, params);
+  GetGLES(context_id)->GetBooleanv(pname, params);
 }
 
 void GetBufferParameteriv(
     PP_Resource context_id, GLenum target, GLenum pname, GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetBufferParameteriv(target, pname, params);
+  GetGLES(context_id)->GetBufferParameteriv(target, pname, params);
 }
 
 GLenum GetError(PP_Resource context_id) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->GetError();
+  return GetGLES(context_id)->GetError();
 }
 
 void GetFloatv(PP_Resource context_id, GLenum pname, GLfloat* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetFloatv(pname, params);
+  GetGLES(context_id)->GetFloatv(pname, params);
 }
 
 void GetFramebufferAttachmentParameteriv(
     PP_Resource context_id, GLenum target, GLenum attachment, GLenum pname,
     GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetFramebufferAttachmentParameteriv(
+  GetGLES(context_id)->GetFramebufferAttachmentParameteriv(
       target, attachment, pname, params);
 }
 
 void GetIntegerv(PP_Resource context_id, GLenum pname, GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetIntegerv(pname, params);
+  GetGLES(context_id)->GetIntegerv(pname, params);
 }
 
 void GetProgramiv(
     PP_Resource context_id, GLuint program, GLenum pname, GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetProgramiv(program, pname, params);
+  GetGLES(context_id)->GetProgramiv(program, pname, params);
 }
 
 void GetProgramInfoLog(
     PP_Resource context_id, GLuint program, GLsizei bufsize, GLsizei* length,
     char* infolog) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetProgramInfoLog(program, bufsize, length, infolog);
+  GetGLES(context_id)->GetProgramInfoLog(program, bufsize, length, infolog);
 }
 
 void GetRenderbufferParameteriv(
     PP_Resource context_id, GLenum target, GLenum pname, GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetRenderbufferParameteriv(target, pname, params);
+  GetGLES(context_id)->GetRenderbufferParameteriv(target, pname, params);
 }
 
 void GetShaderiv(
     PP_Resource context_id, GLuint shader, GLenum pname, GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetShaderiv(shader, pname, params);
+  GetGLES(context_id)->GetShaderiv(shader, pname, params);
 }
 
 void GetShaderInfoLog(
     PP_Resource context_id, GLuint shader, GLsizei bufsize, GLsizei* length,
     char* infolog) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetShaderInfoLog(shader, bufsize, length, infolog);
+  GetGLES(context_id)->GetShaderInfoLog(shader, bufsize, length, infolog);
 }
 
 void GetShaderPrecisionFormat(
     PP_Resource context_id, GLenum shadertype, GLenum precisiontype,
     GLint* range, GLint* precision) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetShaderPrecisionFormat(
+  GetGLES(context_id)->GetShaderPrecisionFormat(
       shadertype, precisiontype, range, precision);
 }
 
 void GetShaderSource(
     PP_Resource context_id, GLuint shader, GLsizei bufsize, GLsizei* length,
     char* source) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetShaderSource(shader, bufsize, length, source);
+  GetGLES(context_id)->GetShaderSource(shader, bufsize, length, source);
 }
 
 const GLubyte* GetString(PP_Resource context_id, GLenum name) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->GetString(name);
+  return GetGLES(context_id)->GetString(name);
 }
 
 void GetTexParameterfv(
     PP_Resource context_id, GLenum target, GLenum pname, GLfloat* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetTexParameterfv(target, pname, params);
+  GetGLES(context_id)->GetTexParameterfv(target, pname, params);
 }
 
 void GetTexParameteriv(
     PP_Resource context_id, GLenum target, GLenum pname, GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetTexParameteriv(target, pname, params);
+  GetGLES(context_id)->GetTexParameteriv(target, pname, params);
 }
 
 void GetUniformfv(
     PP_Resource context_id, GLuint program, GLint location, GLfloat* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetUniformfv(program, location, params);
+  GetGLES(context_id)->GetUniformfv(program, location, params);
 }
 
 void GetUniformiv(
     PP_Resource context_id, GLuint program, GLint location, GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetUniformiv(program, location, params);
+  GetGLES(context_id)->GetUniformiv(program, location, params);
 }
 
 GLint GetUniformLocation(
     PP_Resource context_id, GLuint program, const char* name) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->GetUniformLocation(program, name);
+  return GetGLES(context_id)->GetUniformLocation(program, name);
 }
 
 void GetVertexAttribfv(
     PP_Resource context_id, GLuint index, GLenum pname, GLfloat* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetVertexAttribfv(index, pname, params);
+  GetGLES(context_id)->GetVertexAttribfv(index, pname, params);
 }
 
 void GetVertexAttribiv(
     PP_Resource context_id, GLuint index, GLenum pname, GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetVertexAttribiv(index, pname, params);
+  GetGLES(context_id)->GetVertexAttribiv(index, pname, params);
 }
 
 void GetVertexAttribPointerv(
     PP_Resource context_id, GLuint index, GLenum pname, void** pointer) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->GetVertexAttribPointerv(index, pname, pointer);
+  GetGLES(context_id)->GetVertexAttribPointerv(index, pname, pointer);
 }
 
 void Hint(PP_Resource context_id, GLenum target, GLenum mode) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Hint(target, mode);
+  GetGLES(context_id)->Hint(target, mode);
 }
 
 GLboolean IsBuffer(PP_Resource context_id, GLuint buffer) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->IsBuffer(buffer);
+  return GetGLES(context_id)->IsBuffer(buffer);
 }
 
 GLboolean IsEnabled(PP_Resource context_id, GLenum cap) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->IsEnabled(cap);
+  return GetGLES(context_id)->IsEnabled(cap);
 }
 
 GLboolean IsFramebuffer(PP_Resource context_id, GLuint framebuffer) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->IsFramebuffer(framebuffer);
+  return GetGLES(context_id)->IsFramebuffer(framebuffer);
 }
 
 GLboolean IsProgram(PP_Resource context_id, GLuint program) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->IsProgram(program);
+  return GetGLES(context_id)->IsProgram(program);
 }
 
 GLboolean IsRenderbuffer(PP_Resource context_id, GLuint renderbuffer) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->IsRenderbuffer(renderbuffer);
+  return GetGLES(context_id)->IsRenderbuffer(renderbuffer);
 }
 
 GLboolean IsShader(PP_Resource context_id, GLuint shader) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->IsShader(shader);
+  return GetGLES(context_id)->IsShader(shader);
 }
 
 GLboolean IsTexture(PP_Resource context_id, GLuint texture) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  return context->gles2_impl()->IsTexture(texture);
+  return GetGLES(context_id)->IsTexture(texture);
 }
 
 void LineWidth(PP_Resource context_id, GLfloat width) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->LineWidth(width);
+  GetGLES(context_id)->LineWidth(width);
 }
 
 void LinkProgram(PP_Resource context_id, GLuint program) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->LinkProgram(program);
+  GetGLES(context_id)->LinkProgram(program);
 }
 
 void PixelStorei(PP_Resource context_id, GLenum pname, GLint param) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->PixelStorei(pname, param);
+  GetGLES(context_id)->PixelStorei(pname, param);
 }
 
 void PolygonOffset(PP_Resource context_id, GLfloat factor, GLfloat units) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->PolygonOffset(factor, units);
+  GetGLES(context_id)->PolygonOffset(factor, units);
 }
 
 void ReadPixels(
     PP_Resource context_id, GLint x, GLint y, GLsizei width, GLsizei height,
     GLenum format, GLenum type, void* pixels) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ReadPixels(x, y, width, height, format, type, pixels);
+  GetGLES(context_id)->ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 void ReleaseShaderCompiler(PP_Resource context_id) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ReleaseShaderCompiler();
+  GetGLES(context_id)->ReleaseShaderCompiler();
 }
 
 void RenderbufferStorage(
     PP_Resource context_id, GLenum target, GLenum internalformat, GLsizei width,
     GLsizei height) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->RenderbufferStorage(
+  GetGLES(context_id)->RenderbufferStorage(
       target, internalformat, width, height);
 }
 
 void SampleCoverage(PP_Resource context_id, GLclampf value, GLboolean invert) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->SampleCoverage(value, invert);
+  GetGLES(context_id)->SampleCoverage(value, invert);
 }
 
 void Scissor(
     PP_Resource context_id, GLint x, GLint y, GLsizei width, GLsizei height) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Scissor(x, y, width, height);
+  GetGLES(context_id)->Scissor(x, y, width, height);
 }
 
 void ShaderBinary(
     PP_Resource context_id, GLsizei n, const GLuint* shaders,
     GLenum binaryformat, const void* binary, GLsizei length) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ShaderBinary(
+  GetGLES(context_id)->ShaderBinary(
       n, shaders, binaryformat, binary, length);
 }
 
 void ShaderSource(
     PP_Resource context_id, GLuint shader, GLsizei count, const char** str,
     const GLint* length) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ShaderSource(shader, count, str, length);
+  GetGLES(context_id)->ShaderSource(shader, count, str, length);
 }
 
 void StencilFunc(PP_Resource context_id, GLenum func, GLint ref, GLuint mask) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->StencilFunc(func, ref, mask);
+  GetGLES(context_id)->StencilFunc(func, ref, mask);
 }
 
 void StencilFuncSeparate(
     PP_Resource context_id, GLenum face, GLenum func, GLint ref, GLuint mask) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->StencilFuncSeparate(face, func, ref, mask);
+  GetGLES(context_id)->StencilFuncSeparate(face, func, ref, mask);
 }
 
 void StencilMask(PP_Resource context_id, GLuint mask) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->StencilMask(mask);
+  GetGLES(context_id)->StencilMask(mask);
 }
 
 void StencilMaskSeparate(PP_Resource context_id, GLenum face, GLuint mask) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->StencilMaskSeparate(face, mask);
+  GetGLES(context_id)->StencilMaskSeparate(face, mask);
 }
 
 void StencilOp(
     PP_Resource context_id, GLenum fail, GLenum zfail, GLenum zpass) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->StencilOp(fail, zfail, zpass);
+  GetGLES(context_id)->StencilOp(fail, zfail, zpass);
 }
 
 void StencilOpSeparate(
     PP_Resource context_id, GLenum face, GLenum fail, GLenum zfail,
     GLenum zpass) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->StencilOpSeparate(face, fail, zfail, zpass);
+  GetGLES(context_id)->StencilOpSeparate(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) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->TexImage2D(
+  GetGLES(context_id)->TexImage2D(
       target, level, internalformat, width, height, border, format, type,
       pixels);
 }
 
 void TexParameterf(
     PP_Resource context_id, GLenum target, GLenum pname, GLfloat param) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->TexParameterf(target, pname, param);
+  GetGLES(context_id)->TexParameterf(target, pname, param);
 }
 
 void TexParameterfv(
     PP_Resource context_id, GLenum target, GLenum pname,
     const GLfloat* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->TexParameterfv(target, pname, params);
+  GetGLES(context_id)->TexParameterfv(target, pname, params);
 }
 
 void TexParameteri(
     PP_Resource context_id, GLenum target, GLenum pname, GLint param) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->TexParameteri(target, pname, param);
+  GetGLES(context_id)->TexParameteri(target, pname, param);
 }
 
 void TexParameteriv(
     PP_Resource context_id, GLenum target, GLenum pname, const GLint* params) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->TexParameteriv(target, pname, params);
+  GetGLES(context_id)->TexParameteriv(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) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->TexSubImage2D(
+  GetGLES(context_id)->TexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 void Uniform1f(PP_Resource context_id, GLint location, GLfloat x) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform1f(location, x);
+  GetGLES(context_id)->Uniform1f(location, x);
 }
 
 void Uniform1fv(
     PP_Resource context_id, GLint location, GLsizei count, const GLfloat* v) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform1fv(location, count, v);
+  GetGLES(context_id)->Uniform1fv(location, count, v);
 }
 
 void Uniform1i(PP_Resource context_id, GLint location, GLint x) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform1i(location, x);
+  GetGLES(context_id)->Uniform1i(location, x);
 }
 
 void Uniform1iv(
     PP_Resource context_id, GLint location, GLsizei count, const GLint* v) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform1iv(location, count, v);
+  GetGLES(context_id)->Uniform1iv(location, count, v);
 }
 
 void Uniform2f(PP_Resource context_id, GLint location, GLfloat x, GLfloat y) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform2f(location, x, y);
+  GetGLES(context_id)->Uniform2f(location, x, y);
 }
 
 void Uniform2fv(
     PP_Resource context_id, GLint location, GLsizei count, const GLfloat* v) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform2fv(location, count, v);
+  GetGLES(context_id)->Uniform2fv(location, count, v);
 }
 
 void Uniform2i(PP_Resource context_id, GLint location, GLint x, GLint y) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform2i(location, x, y);
+  GetGLES(context_id)->Uniform2i(location, x, y);
 }
 
 void Uniform2iv(
     PP_Resource context_id, GLint location, GLsizei count, const GLint* v) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform2iv(location, count, v);
+  GetGLES(context_id)->Uniform2iv(location, count, v);
 }
 
 void Uniform3f(
     PP_Resource context_id, GLint location, GLfloat x, GLfloat y, GLfloat z) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform3f(location, x, y, z);
+  GetGLES(context_id)->Uniform3f(location, x, y, z);
 }
 
 void Uniform3fv(
     PP_Resource context_id, GLint location, GLsizei count, const GLfloat* v) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform3fv(location, count, v);
+  GetGLES(context_id)->Uniform3fv(location, count, v);
 }
 
 void Uniform3i(
     PP_Resource context_id, GLint location, GLint x, GLint y, GLint z) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform3i(location, x, y, z);
+  GetGLES(context_id)->Uniform3i(location, x, y, z);
 }
 
 void Uniform3iv(
     PP_Resource context_id, GLint location, GLsizei count, const GLint* v) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform3iv(location, count, v);
+  GetGLES(context_id)->Uniform3iv(location, count, v);
 }
 
 void Uniform4f(
     PP_Resource context_id, GLint location, GLfloat x, GLfloat y, GLfloat z,
     GLfloat w) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform4f(location, x, y, z, w);
+  GetGLES(context_id)->Uniform4f(location, x, y, z, w);
 }
 
 void Uniform4fv(
     PP_Resource context_id, GLint location, GLsizei count, const GLfloat* v) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform4fv(location, count, v);
+  GetGLES(context_id)->Uniform4fv(location, count, v);
 }
 
 void Uniform4i(
     PP_Resource context_id, GLint location, GLint x, GLint y, GLint z,
     GLint w) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform4i(location, x, y, z, w);
+  GetGLES(context_id)->Uniform4i(location, x, y, z, w);
 }
 
 void Uniform4iv(
     PP_Resource context_id, GLint location, GLsizei count, const GLint* v) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Uniform4iv(location, count, v);
+  GetGLES(context_id)->Uniform4iv(location, count, v);
 }
 
 void UniformMatrix2fv(
     PP_Resource context_id, GLint location, GLsizei count, GLboolean transpose,
     const GLfloat* value) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->UniformMatrix2fv(location, count, transpose, value);
+  GetGLES(context_id)->UniformMatrix2fv(location, count, transpose, value);
 }
 
 void UniformMatrix3fv(
     PP_Resource context_id, GLint location, GLsizei count, GLboolean transpose,
     const GLfloat* value) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->UniformMatrix3fv(location, count, transpose, value);
+  GetGLES(context_id)->UniformMatrix3fv(location, count, transpose, value);
 }
 
 void UniformMatrix4fv(
     PP_Resource context_id, GLint location, GLsizei count, GLboolean transpose,
     const GLfloat* value) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->UniformMatrix4fv(location, count, transpose, value);
+  GetGLES(context_id)->UniformMatrix4fv(location, count, transpose, value);
 }
 
 void UseProgram(PP_Resource context_id, GLuint program) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->UseProgram(program);
+  GetGLES(context_id)->UseProgram(program);
 }
 
 void ValidateProgram(PP_Resource context_id, GLuint program) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->ValidateProgram(program);
+  GetGLES(context_id)->ValidateProgram(program);
 }
 
 void VertexAttrib1f(PP_Resource context_id, GLuint indx, GLfloat x) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttrib1f(indx, x);
+  GetGLES(context_id)->VertexAttrib1f(indx, x);
 }
 
 void VertexAttrib1fv(
     PP_Resource context_id, GLuint indx, const GLfloat* values) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttrib1fv(indx, values);
+  GetGLES(context_id)->VertexAttrib1fv(indx, values);
 }
 
 void VertexAttrib2f(
     PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttrib2f(indx, x, y);
+  GetGLES(context_id)->VertexAttrib2f(indx, x, y);
 }
 
 void VertexAttrib2fv(
     PP_Resource context_id, GLuint indx, const GLfloat* values) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttrib2fv(indx, values);
+  GetGLES(context_id)->VertexAttrib2fv(indx, values);
 }
 
 void VertexAttrib3f(
     PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttrib3f(indx, x, y, z);
+  GetGLES(context_id)->VertexAttrib3f(indx, x, y, z);
 }
 
 void VertexAttrib3fv(
     PP_Resource context_id, GLuint indx, const GLfloat* values) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttrib3fv(indx, values);
+  GetGLES(context_id)->VertexAttrib3fv(indx, values);
 }
 
 void VertexAttrib4f(
     PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y, GLfloat z,
     GLfloat w) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttrib4f(indx, x, y, z, w);
+  GetGLES(context_id)->VertexAttrib4f(indx, x, y, z, w);
 }
 
 void VertexAttrib4fv(
     PP_Resource context_id, GLuint indx, const GLfloat* values) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttrib4fv(indx, values);
+  GetGLES(context_id)->VertexAttrib4fv(indx, values);
 }
 
 void VertexAttribPointer(
     PP_Resource context_id, GLuint indx, GLint size, GLenum type,
     GLboolean normalized, GLsizei stride, const void* ptr) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->VertexAttribPointer(
+  GetGLES(context_id)->VertexAttribPointer(
       indx, size, type, normalized, stride, ptr);
 }
 
 void Viewport(
     PP_Resource context_id, GLint x, GLint y, GLsizei width, GLsizei height) {
-  Context3D* context = PluginResource::GetAs<Context3D>(context_id);
-  context->gles2_impl()->Viewport(x, y, width, height);
+  GetGLES(context_id)->Viewport(x, y, width, height);
 }
 
 const struct PPB_OpenGLES2_Dev opengles2_interface = {