Make WebGraphics3DCommandBufferImpl use GLES2Implemenation directly.

content/renderer/webgraphicscontext3d_command_buffer_impl.cc

 // Copyright (c) 2011 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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/renderer/webgraphicscontext3d_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include <GLES2/gl2ext.h>
 
 #include <algorithm>
 
 #include "base/string_tokenizer.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "content/common/content_switches.h"
 #include "content/renderer/gpu_channel_host.h"
 #include "content/renderer/render_thread.h"
 #include "content/renderer/render_view.h"
+#include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/gl_bindings_skia_cmd_buffer.h"
 
+#if defined(USE_REAL_GL_API)
+#define CALL_GL_IMPL(name) gl##name
+inline void WebGraphicsContext3DCommandBufferImpl::localMakeContextCurrent() {
+  makeContextCurrent();
+}
+#else
+#define CALL_GL_IMPL(name) (gles2_implementation_->name)
+inline void WebGraphicsContext3DCommandBufferImpl::localMakeContextCurrent() {
+}
+#endif
+
 WebGraphicsContext3DCommandBufferImpl::WebGraphicsContext3DCommandBufferImpl()
     : context_(NULL),
+      gles2_implementation_(NULL),
       web_view_(NULL),
 #if defined(OS_MACOSX)
       plugin_handle_(NULL),
 #endif  // defined(OS_MACOSX)
       context_lost_callback_(0),
       cached_width_(0),
       cached_height_(0),
       bound_fbo_(0) {
 }
 
@@ skipping 94 matching lines @@
         parent_context,
         gfx::Size(1, 1),
         kWebGraphicsContext3DPerferredGLExtensions,
         attribs,
         active_url);
     web_view_ = NULL;
   }
   if (!context_)
     return false;
 
+  gles2_implementation_ = context_->GetImplementation();
   context_->SetContextLostCallback(
       NewCallback(this,
                   &WebGraphicsContext3DCommandBufferImpl::OnContextLost));
 
   // TODO(gman): Remove this.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kDisableGLSLTranslator)) {
     context_->DisableShaderTranslation();
   }
 
@@ skipping 40 matching lines @@
 
 void WebGraphicsContext3DCommandBufferImpl::prepareTexture() {
   // Copies the contents of the off-screen render target into the texture
   // used by the compositor.
   context_->SwapBuffers();
 }
 
 void WebGraphicsContext3DCommandBufferImpl::reshape(int width, int height) {
   cached_width_ = width;
   cached_height_ = height;
-  makeContextCurrent();
+  localMakeContextCurrent();

[Ken Russell (switch to Gerrit), 2011/05/21 01:09:21]

I thought the reason for this change was to make the implementation more robust
by eliminating the need for making context_ current, at least in the majority of
the entry points (I don't know about CreateParentTexture, DeleteParentTexture,
etc.). If that's the case then we should just get rid of the macro, go through
the GLES2Implementation, and delete the calls to makeContextCurrent (or at least
all that can be deleted) rather than adding the new localMakeContextCurrent.

[greggman, 2011/05/21 01:22:49]

You're right.  I changed it to the simpler way.

 
   if (web_view_) {
 #if defined(OS_MACOSX)
     context_->ResizeOnscreen(gfx::Size(width, height));
 #else
-    glResizeCHROMIUM(width, height);
+    CALL_GL_IMPL(ResizeCHROMIUM)(width, height);
 #endif
   } else {
     context_->ResizeOffscreen(gfx::Size(width, height));
     // Force a SwapBuffers to get the framebuffer to resize.
     context_->SwapBuffers();
   }
 
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
   scanline_.reset(new uint8[width * 4]);
 #endif  // FLIP_FRAMEBUFFER_VERTICALLY
 }
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::createCompositorTexture(
     WGC3Dsizei width, WGC3Dsizei height) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   return context_->CreateParentTexture(gfx::Size(width, height));
 }
 
 void WebGraphicsContext3DCommandBufferImpl::deleteCompositorTexture(
     WebGLId parent_texture) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   context_->DeleteParentTexture(parent_texture);
 }
 
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
 void WebGraphicsContext3DCommandBufferImpl::FlipVertically(
     uint8* framebuffer,
     unsigned int width,
     unsigned int height) {
   uint8* scanline = scanline_.get();
   if (!scanline)
@@ skipping 14 matching lines @@
 }
 #endif
 
 bool WebGraphicsContext3DCommandBufferImpl::readBackFramebuffer(
     unsigned char* pixels,
     size_t buffer_size) {
   if (buffer_size != static_cast<size_t>(4 * width() * height())) {
     return false;
   }
 
-  makeContextCurrent();
+  localMakeContextCurrent();
 
   // Earlier versions of this code used the GPU to flip the
   // framebuffer vertically before reading it back for compositing
   // via software. This code was quite complicated, used a lot of
   // GPU memory, and didn't provide an obvious speedup. Since this
   // vertical flip is only a temporary solution anyway until Chrome
   // is fully GPU composited, it wasn't worth the complexity.
 
   bool mustRestoreFBO = (bound_fbo_ != 0);
   if (mustRestoreFBO) {
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    CALL_GL_IMPL(BindFramebuffer)(GL_FRAMEBUFFER, 0);
   }
-  glReadPixels(0, 0, cached_width_, cached_height_,
-               GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+   CALL_GL_IMPL(ReadPixels)(0, 0, cached_width_, cached_height_,
+                            GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
   // Swizzle red and blue channels
   // TODO(kbr): expose GL_BGRA as extension
   for (size_t i = 0; i < buffer_size; i += 4) {
     std::swap(pixels[i], pixels[i + 2]);
   }
 
   if (mustRestoreFBO) {
-    glBindFramebuffer(GL_FRAMEBUFFER, bound_fbo_);
+    CALL_GL_IMPL(BindFramebuffer)(GL_FRAMEBUFFER, bound_fbo_);
   }
 
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
   if (pixels) {
     FlipVertically(pixels, cached_width_, cached_height_);
   }
 #endif
 
   return true;
 }
 
 void WebGraphicsContext3DCommandBufferImpl::synthesizeGLError(
     WGC3Denum error) {
   if (find(synthetic_errors_.begin(), synthetic_errors_.end(), error) ==
       synthetic_errors_.end()) {
     synthetic_errors_.push_back(error);
   }
 }
 
 void* WebGraphicsContext3DCommandBufferImpl::mapBufferSubDataCHROMIUM(
     WGC3Denum target,
     WGC3Dintptr offset,
     WGC3Dsizeiptr size,
     WGC3Denum access) {
-  makeContextCurrent();
-  return glMapBufferSubDataCHROMIUM(target, offset, size, access);
+  localMakeContextCurrent();
+  return CALL_GL_IMPL(MapBufferSubDataCHROMIUM)(target, offset, size, access);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::unmapBufferSubDataCHROMIUM(
     const void* mem) {
-  makeContextCurrent();
-  return glUnmapBufferSubDataCHROMIUM(mem);
+  localMakeContextCurrent();
+  return CALL_GL_IMPL(UnmapBufferSubDataCHROMIUM)(mem);
 }
 
 void* WebGraphicsContext3DCommandBufferImpl::mapTexSubImage2DCHROMIUM(
     WGC3Denum target,
     WGC3Dint level,
     WGC3Dint xoffset,
     WGC3Dint yoffset,
     WGC3Dsizei width,
     WGC3Dsizei height,
     WGC3Denum format,
     WGC3Denum type,
     WGC3Denum access) {
-  return glMapTexSubImage2DCHROMIUM(
+  return CALL_GL_IMPL(MapTexSubImage2DCHROMIUM)(
       target, level, xoffset, yoffset, width, height, format, type, access);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::unmapTexSubImage2DCHROMIUM(
     const void* mem) {
-  makeContextCurrent();
-  glUnmapTexSubImage2DCHROMIUM(mem);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(UnmapTexSubImage2DCHROMIUM)(mem);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::copyTextureToParentTextureCHROMIUM(
     WebGLId texture, WebGLId parentTexture) {
   copyTextureToCompositor(texture, parentTexture);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::getParentToChildLatchCHROMIUM(
     WGC3Duint* latch_id)
 {
@@ skipping 10 matching lines @@
   if (!context_->GetChildToParentLatch(latch_id)) {
     LOG(ERROR) << "getLatch must only be called on child context";
     synthesizeGLError(GL_INVALID_OPERATION);
     *latch_id = gpu::kInvalidLatchId;
   }
 }
 
 void WebGraphicsContext3DCommandBufferImpl::waitLatchCHROMIUM(
     WGC3Duint latch_id)
 {
-  makeContextCurrent();
-  glWaitLatchCHROMIUM(latch_id);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(WaitLatchCHROMIUM)(latch_id);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::setLatchCHROMIUM(
     WGC3Duint latch_id)
 {
-  makeContextCurrent();
-  glSetLatchCHROMIUM(latch_id);
-  glFlush(); // required to ensure set command is sent to GPU process
+  localMakeContextCurrent();
+  CALL_GL_IMPL(SetLatchCHROMIUM)(latch_id);
+  // required to ensure set command is sent to GPU process
+  CALL_GL_IMPL(Flush)();
 }
 
 void WebGraphicsContext3DCommandBufferImpl::
     rateLimitOffscreenContextCHROMIUM() {
-  makeContextCurrent();
-  glRateLimitOffscreenContextCHROMIUM();
+  localMakeContextCurrent();
+  CALL_GL_IMPL(RateLimitOffscreenContextCHROMIUM)();
 }
 
 WebKit::WebString WebGraphicsContext3DCommandBufferImpl::
     getRequestableExtensionsCHROMIUM() {
-  makeContextCurrent();
-  return WebKit::WebString::fromUTF8(glGetRequestableExtensionsCHROMIUM());
+  localMakeContextCurrent();
+  return WebKit::WebString::fromUTF8(
+      CALL_GL_IMPL(GetRequestableExtensionsCHROMIUM)());
 }
 
 void WebGraphicsContext3DCommandBufferImpl::requestExtensionCHROMIUM(
     const char* extension) {
-  makeContextCurrent();
-  glRequestExtensionCHROMIUM(extension);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(RequestExtensionCHROMIUM)(extension);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::blitFramebufferCHROMIUM(
     WGC3Dint srcX0, WGC3Dint srcY0, WGC3Dint srcX1, WGC3Dint srcY1,
     WGC3Dint dstX0, WGC3Dint dstY0, WGC3Dint dstX1, WGC3Dint dstY1,
     WGC3Dbitfield mask, WGC3Denum filter) {
-  makeContextCurrent();
-  glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1,
-                       dstX0, dstY0, dstX1, dstY1,
-                       mask, filter);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(BlitFramebufferEXT)(
+      srcX0, srcY0, srcX1, srcY1,
+      dstX0, dstY0, dstX1, dstY1,
+      mask, filter);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::
     renderbufferStorageMultisampleCHROMIUM(
         WGC3Denum target, WGC3Dsizei samples, WGC3Denum internalformat,
         WGC3Dsizei width, WGC3Dsizei height) {
-  makeContextCurrent();
-  glRenderbufferStorageMultisampleEXT(target, samples, internalformat,
-                                      width, height);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(RenderbufferStorageMultisampleEXT)(
+      target, samples, internalformat, width, height);
 }
 
 // Helper macros to reduce the amount of code.
 
 #define DELEGATE_TO_GL(name, glname)                                    \
 void WebGraphicsContext3DCommandBufferImpl::name() {                    \
-  makeContextCurrent();                                                 \
-  gl##glname();                                                         \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)();                                               \
 }
 
 #define DELEGATE_TO_GL_1(name, glname, t1)                              \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1) {               \
-  makeContextCurrent();                                                 \
-  gl##glname(a1);                                                       \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1);                                             \
 }
 
 #define DELEGATE_TO_GL_1R(name, glname, t1, rt)                         \
 rt WebGraphicsContext3DCommandBufferImpl::name(t1 a1) {                 \
-  makeContextCurrent();                                                 \
-  return gl##glname(a1);                                                \
+  localMakeContextCurrent();                                            \
+  return CALL_GL_IMPL(glname)(a1);                                      \
 }
 
 #define DELEGATE_TO_GL_1RB(name, glname, t1, rt)                        \
 rt WebGraphicsContext3DCommandBufferImpl::name(t1 a1) {                 \
-  makeContextCurrent();                                                 \
-  return gl##glname(a1) ? true : false;                                 \
+  localMakeContextCurrent();                                            \
+  return CALL_GL_IMPL(glname)(a1) ? true : false;                       \
 }
 
 #define DELEGATE_TO_GL_2(name, glname, t1, t2)                          \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2) {        \
-  makeContextCurrent();                                                 \
-  gl##glname(a1, a2);                                                   \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1, a2);                                         \
 }
 
 #define DELEGATE_TO_GL_2R(name, glname, t1, t2, rt)                     \
 rt WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2) {          \
-  makeContextCurrent();                                                 \
-  return gl##glname(a1, a2);                                            \
+  localMakeContextCurrent();                                            \
+  return CALL_GL_IMPL(glname)(a1, a2);                                  \
 }
 
 #define DELEGATE_TO_GL_3(name, glname, t1, t2, t3)                      \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2, t3 a3) { \
-  makeContextCurrent();                                                 \
-  gl##glname(a1, a2, a3);                                               \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1, a2, a3);                                     \
 }
 
 #define DELEGATE_TO_GL_4(name, glname, t1, t2, t3, t4)                  \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2, t3 a3, t4 a4) { \
-  makeContextCurrent();                                                 \
-  gl##glname(a1, a2, a3, a4);                                           \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1, a2, a3, a4);                                 \
 }
 
 #define DELEGATE_TO_GL_5(name, glname, t1, t2, t3, t4, t5)              \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2, t3 a3,   \
                                                  t4 a4, t5 a5) {        \
-  makeContextCurrent();                                                 \
-  gl##glname(a1, a2, a3, a4, a5);                                       \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1, a2, a3, a4, a5);                             \
 }
 
 #define DELEGATE_TO_GL_6(name, glname, t1, t2, t3, t4, t5, t6)          \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2, t3 a3,   \
                                                  t4 a4, t5 a5, t6 a6) { \
-  makeContextCurrent();                                                 \
-  gl##glname(a1, a2, a3, a4, a5, a6);                                   \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1, a2, a3, a4, a5, a6);                         \
 }
 
 #define DELEGATE_TO_GL_7(name, glname, t1, t2, t3, t4, t5, t6, t7)      \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2, t3 a3,   \
                                                  t4 a4, t5 a5, t6 a6, t7 a7) { \
-  makeContextCurrent();                                                 \
-  gl##glname(a1, a2, a3, a4, a5, a6, a7);                               \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1, a2, a3, a4, a5, a6, a7);                     \
 }
 
 #define DELEGATE_TO_GL_8(name, glname, t1, t2, t3, t4, t5, t6, t7, t8)  \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2, t3 a3,   \
                                                  t4 a4, t5 a5, t6 a6,   \
                                                  t7 a7, t8 a8) {        \
-  makeContextCurrent();                                                 \
-  gl##glname(a1, a2, a3, a4, a5, a6, a7, a8);                           \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1, a2, a3, a4, a5, a6, a7, a8);                 \
 }
 
 #define DELEGATE_TO_GL_9(name, glname, t1, t2, t3, t4, t5, t6, t7, t8, t9) \
 void WebGraphicsContext3DCommandBufferImpl::name(t1 a1, t2 a2, t3 a3,   \
                                                  t4 a4, t5 a5, t6 a6,   \
                                                  t7 a7, t8 a8, t9 a9) { \
-  makeContextCurrent();                                                 \
-  gl##glname(a1, a2, a3, a4, a5, a6, a7, a8, a9);                       \
+  localMakeContextCurrent();                                            \
+  CALL_GL_IMPL(glname)(a1, a2, a3, a4, a5, a6, a7, a8, a9);             \
 }
 
 DELEGATE_TO_GL_1(activeTexture, ActiveTexture, WGC3Denum)
 
 DELEGATE_TO_GL_2(attachShader, AttachShader, WebGLId, WebGLId)
 
 DELEGATE_TO_GL_3(bindAttribLocation, BindAttribLocation, WebGLId,
                  WGC3Duint, const WGC3Dchar*)
 
 DELEGATE_TO_GL_2(bindBuffer, BindBuffer, WGC3Denum, WebGLId)
 
 void WebGraphicsContext3DCommandBufferImpl::bindFramebuffer(
     WGC3Denum target,
     WebGLId framebuffer) {
-  makeContextCurrent();
-  glBindFramebuffer(target, framebuffer);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(BindFramebuffer)(target, framebuffer);
   bound_fbo_ = framebuffer;
 }
 
 DELEGATE_TO_GL_2(bindRenderbuffer, BindRenderbuffer, WGC3Denum, WebGLId)
 
 DELEGATE_TO_GL_2(bindTexture, BindTexture, WGC3Denum, WebGLId)
 
 DELEGATE_TO_GL_4(blendColor, BlendColor,
                  WGC3Dclampf, WGC3Dclampf, WGC3Dclampf, WGC3Dclampf)
 
@@ skipping 52 matching lines @@
 
 DELEGATE_TO_GL_1(disableVertexAttribArray, DisableVertexAttribArray,
                  WGC3Duint)
 
 DELEGATE_TO_GL_3(drawArrays, DrawArrays, WGC3Denum, WGC3Dint, WGC3Dsizei)
 
 void WebGraphicsContext3DCommandBufferImpl::drawElements(WGC3Denum mode,
                                                          WGC3Dsizei count,
                                                          WGC3Denum type,
                                                          WGC3Dintptr offset) {
-  makeContextCurrent();
-  glDrawElements(mode, count, type,
-                 reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
+  localMakeContextCurrent();
+  CALL_GL_IMPL(DrawElements)(
+      mode, count, type,
+      reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
 }
 
 DELEGATE_TO_GL_1(enable, Enable, WGC3Denum)
 
 DELEGATE_TO_GL_1(enableVertexAttribArray, EnableVertexAttribArray,
                  WGC3Duint)
 
 DELEGATE_TO_GL(finish, Finish)
 
 DELEGATE_TO_GL(flush, Flush)
 
 DELEGATE_TO_GL_4(framebufferRenderbuffer, FramebufferRenderbuffer,
                  WGC3Denum, WGC3Denum, WGC3Denum, WebGLId)
 
 DELEGATE_TO_GL_5(framebufferTexture2D, FramebufferTexture2D,
                  WGC3Denum, WGC3Denum, WGC3Denum, WebGLId, WGC3Dint)
 
 DELEGATE_TO_GL_1(frontFace, FrontFace, WGC3Denum)
 
 DELEGATE_TO_GL_1(generateMipmap, GenerateMipmap, WGC3Denum)
 
 bool WebGraphicsContext3DCommandBufferImpl::getActiveAttrib(
     WebGLId program, WGC3Duint index, ActiveInfo& info) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   if (!program) {
     synthesizeGLError(GL_INVALID_VALUE);
     return false;
   }
   GLint max_name_length = -1;
-  glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_name_length);
+  CALL_GL_IMPL(GetProgramiv)(
+      program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_name_length);
   if (max_name_length < 0)
     return false;
   scoped_array<GLchar> name(new GLchar[max_name_length]);
   if (!name.get()) {
     synthesizeGLError(GL_OUT_OF_MEMORY);
     return false;
   }
   GLsizei length = 0;
   GLint size = -1;
   GLenum type = 0;
-  glGetActiveAttrib(program, index, max_name_length,
-                    &length, &size, &type, name.get());
+  CALL_GL_IMPL(GetActiveAttrib)(
+      program, index, max_name_length, &length, &size, &type, name.get());
   if (size < 0) {
     return false;
   }
   info.name = WebKit::WebString::fromUTF8(name.get(), length);
   info.type = type;
   info.size = size;
   return true;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::getActiveUniform(
     WebGLId program, WGC3Duint index, ActiveInfo& info) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLint max_name_length = -1;
-  glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_name_length);
+  CALL_GL_IMPL(GetProgramiv)(
+      program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_name_length);
   if (max_name_length < 0)
     return false;
   scoped_array<GLchar> name(new GLchar[max_name_length]);
   if (!name.get()) {
     synthesizeGLError(GL_OUT_OF_MEMORY);
     return false;
   }
   GLsizei length = 0;
   GLint size = -1;
   GLenum type = 0;
-  glGetActiveUniform(program, index, max_name_length,
-                     &length, &size, &type, name.get());
+  CALL_GL_IMPL(GetActiveUniform)(
+      program, index, max_name_length, &length, &size, &type, name.get());
   if (size < 0) {
     return false;
   }
   info.name = WebKit::WebString::fromUTF8(name.get(), length);
   info.type = type;
   info.size = size;
   return true;
 }
 
 DELEGATE_TO_GL_4(getAttachedShaders, GetAttachedShaders,
@@ skipping 13 matching lines @@
 }
 
 WGC3Denum WebGraphicsContext3DCommandBufferImpl::getError() {
   if (!synthetic_errors_.empty()) {
     std::vector<WGC3Denum>::iterator iter = synthetic_errors_.begin();
     WGC3Denum err = *iter;
     synthetic_errors_.erase(iter);
     return err;
   }
 
-  makeContextCurrent();
-  return glGetError();
+  localMakeContextCurrent();
+  return CALL_GL_IMPL(GetError)();
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::isContextLost() {
   return context_->IsCommandBufferContextLost();
 }
 
 DELEGATE_TO_GL_2(getFloatv, GetFloatv, WGC3Denum, WGC3Dfloat*)
 
 DELEGATE_TO_GL_4(getFramebufferAttachmentParameteriv,
                  GetFramebufferAttachmentParameteriv,
                  WGC3Denum, WGC3Denum, WGC3Denum, WGC3Dint*)
 
 DELEGATE_TO_GL_2(getIntegerv, GetIntegerv, WGC3Denum, WGC3Dint*)
 
 DELEGATE_TO_GL_3(getProgramiv, GetProgramiv, WebGLId, WGC3Denum, WGC3Dint*)
 
 WebKit::WebString WebGraphicsContext3DCommandBufferImpl::getProgramInfoLog(
     WebGLId program) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLint logLength = 0;
-  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
+  CALL_GL_IMPL(GetProgramiv)(program, GL_INFO_LOG_LENGTH, &logLength);
   if (!logLength)
     return WebKit::WebString();
   scoped_array<GLchar> log(new GLchar[logLength]);
   if (!log.get())
     return WebKit::WebString();
   GLsizei returnedLogLength = 0;
-  glGetProgramInfoLog(program, logLength, &returnedLogLength, log.get());
+  CALL_GL_IMPL(GetProgramInfoLog)(
+      program, logLength, &returnedLogLength, log.get());
   DCHECK_EQ(logLength, returnedLogLength + 1);
   WebKit::WebString res =
       WebKit::WebString::fromUTF8(log.get(), returnedLogLength);
   return res;
 }
 
 DELEGATE_TO_GL_3(getRenderbufferParameteriv, GetRenderbufferParameteriv,
                  WGC3Denum, WGC3Denum, WGC3Dint*)
 
 DELEGATE_TO_GL_3(getShaderiv, GetShaderiv, WebGLId, WGC3Denum, WGC3Dint*)
 
 WebKit::WebString WebGraphicsContext3DCommandBufferImpl::getShaderInfoLog(
     WebGLId shader) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLint logLength = 0;
-  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
+  CALL_GL_IMPL(GetShaderiv)(shader, GL_INFO_LOG_LENGTH, &logLength);
   if (!logLength)
     return WebKit::WebString();
   scoped_array<GLchar> log(new GLchar[logLength]);
   if (!log.get())
     return WebKit::WebString();
   GLsizei returnedLogLength = 0;
-  glGetShaderInfoLog(shader, logLength, &returnedLogLength, log.get());
+  CALL_GL_IMPL(GetShaderInfoLog)(
+      shader, logLength, &returnedLogLength, log.get());
   DCHECK_EQ(logLength, returnedLogLength + 1);
   WebKit::WebString res =
       WebKit::WebString::fromUTF8(log.get(), returnedLogLength);
   return res;
 }
 
 WebKit::WebString WebGraphicsContext3DCommandBufferImpl::getShaderSource(
     WebGLId shader) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLint logLength = 0;
-  glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &logLength);
+  CALL_GL_IMPL(GetShaderiv)(shader, GL_SHADER_SOURCE_LENGTH, &logLength);
   if (!logLength)
     return WebKit::WebString();
   scoped_array<GLchar> log(new GLchar[logLength]);
   if (!log.get())
     return WebKit::WebString();
   GLsizei returnedLogLength = 0;
-  glGetShaderSource(shader, logLength, &returnedLogLength, log.get());
+  CALL_GL_IMPL(GetShaderSource)(
+      shader, logLength, &returnedLogLength, log.get());
   DCHECK_EQ(logLength, returnedLogLength + 1);
   WebKit::WebString res =
       WebKit::WebString::fromUTF8(log.get(), returnedLogLength);
   return res;
 }
 
 WebKit::WebString WebGraphicsContext3DCommandBufferImpl::getString(
     WGC3Denum name) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   return WebKit::WebString::fromUTF8(
-      reinterpret_cast<const char*>(glGetString(name)));
+      reinterpret_cast<const char*>(CALL_GL_IMPL(GetString)(name)));
 }
 
 DELEGATE_TO_GL_3(getTexParameterfv, GetTexParameterfv,
                  WGC3Denum, WGC3Denum, WGC3Dfloat*)
 
 DELEGATE_TO_GL_3(getTexParameteriv, GetTexParameteriv,
                  WGC3Denum, WGC3Denum, WGC3Dint*)
 
 DELEGATE_TO_GL_3(getUniformfv, GetUniformfv, WebGLId, WGC3Dint, WGC3Dfloat*)
 
 DELEGATE_TO_GL_3(getUniformiv, GetUniformiv, WebGLId, WGC3Dint, WGC3Dint*)
 
 DELEGATE_TO_GL_2R(getUniformLocation, GetUniformLocation,
                   WebGLId, const WGC3Dchar*, WGC3Dint)
 
 DELEGATE_TO_GL_3(getVertexAttribfv, GetVertexAttribfv,
                  WGC3Duint, WGC3Denum, WGC3Dfloat*)
 
 DELEGATE_TO_GL_3(getVertexAttribiv, GetVertexAttribiv,
                  WGC3Duint, WGC3Denum, WGC3Dint*)
 
 WGC3Dsizeiptr WebGraphicsContext3DCommandBufferImpl::getVertexAttribOffset(
     WGC3Duint index, WGC3Denum pname) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLvoid* value = NULL;
   // NOTE: If pname is ever a value that returns more then 1 element
   // this will corrupt memory.
-  glGetVertexAttribPointerv(index, pname, &value);
+  CALL_GL_IMPL(GetVertexAttribPointerv)(index, pname, &value);
   return static_cast<WGC3Dsizeiptr>(reinterpret_cast<intptr_t>(value));
 }
 
 DELEGATE_TO_GL_2(hint, Hint, WGC3Denum, WGC3Denum)
 
 DELEGATE_TO_GL_1RB(isBuffer, IsBuffer, WebGLId, WGC3Dboolean)
 
 DELEGATE_TO_GL_1RB(isEnabled, IsEnabled, WGC3Denum, WGC3Dboolean)
 
 DELEGATE_TO_GL_1RB(isFramebuffer, IsFramebuffer, WebGLId, WGC3Dboolean)
@@ skipping 23 matching lines @@
 
 DELEGATE_TO_GL_4(renderbufferStorage, RenderbufferStorage,
                  WGC3Denum, WGC3Denum, WGC3Dsizei, WGC3Dsizei)
 
 DELEGATE_TO_GL_2(sampleCoverage, SampleCoverage, WGC3Dfloat, WGC3Dboolean)
 
 DELEGATE_TO_GL_4(scissor, Scissor, WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei)
 
 void WebGraphicsContext3DCommandBufferImpl::shaderSource(
     WebGLId shader, const WGC3Dchar* string) {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLint length = strlen(string);
-  glShaderSource(shader, 1, &string, &length);
+  CALL_GL_IMPL(ShaderSource)(shader, 1, &string, &length);
 }
 
 DELEGATE_TO_GL_3(stencilFunc, StencilFunc, WGC3Denum, WGC3Dint, WGC3Duint)
 
 DELEGATE_TO_GL_4(stencilFuncSeparate, StencilFuncSeparate,
                  WGC3Denum, WGC3Denum, WGC3Dint, WGC3Duint)
 
 DELEGATE_TO_GL_1(stencilMask, StencilMask, WGC3Duint)
 
 DELEGATE_TO_GL_2(stencilMaskSeparate, StencilMaskSeparate,
@@ skipping 16 matching lines @@
 
 void WebGraphicsContext3DCommandBufferImpl::texParameteri(
     WGC3Denum target, WGC3Denum pname, WGC3Dint param) {
   // TODO(kbr): figure out whether the setting of TEXTURE_WRAP_R in
   // GraphicsContext3D.cpp is strictly necessary to avoid seams at the
   // edge of cube maps, and, if it is, push it into the GLES2 service
   // side code.
   if (pname == kTextureWrapR) {
     return;
   }
-  makeContextCurrent();
-  glTexParameteri(target, pname, param);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(TexParameteri)(target, pname, param);
 }
 
 DELEGATE_TO_GL_9(texSubImage2D, TexSubImage2D,
                  WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei,
                  WGC3Dsizei, WGC3Denum, WGC3Denum, const void*)
 
 DELEGATE_TO_GL_2(uniform1f, Uniform1f, WGC3Dint, WGC3Dfloat)
 
 DELEGATE_TO_GL_3(uniform1fv, Uniform1fv, WGC3Dint, WGC3Dsizei,
                  const WGC3Dfloat*)
@@ skipping 64 matching lines @@
 
 DELEGATE_TO_GL_5(vertexAttrib4f, VertexAttrib4f, WGC3Duint,
                  WGC3Dfloat, WGC3Dfloat, WGC3Dfloat, WGC3Dfloat)
 
 DELEGATE_TO_GL_2(vertexAttrib4fv, VertexAttrib4fv, WGC3Duint,
                  const WGC3Dfloat*)
 
 void WebGraphicsContext3DCommandBufferImpl::vertexAttribPointer(
     WGC3Duint index, WGC3Dint size, WGC3Denum type, WGC3Dboolean normalized,
     WGC3Dsizei stride, WGC3Dintptr offset) {
-  makeContextCurrent();
+  localMakeContextCurrent();
 
-  glVertexAttribPointer(index, size, type, normalized, stride,
-                        reinterpret_cast<void*>(
-                            static_cast<intptr_t>(offset)));
+  CALL_GL_IMPL(VertexAttribPointer)(
+      index, size, type, normalized, stride,
+      reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
 }
 
 DELEGATE_TO_GL_4(viewport, Viewport,
                  WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei)
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::createBuffer() {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLuint o;
-  glGenBuffers(1, &o);
+  CALL_GL_IMPL(GenBuffers)(1, &o);
   return o;
 }
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::createFramebuffer() {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLuint o = 0;
-  glGenFramebuffers(1, &o);
+  CALL_GL_IMPL(GenFramebuffers)(1, &o);
   return o;
 }
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::createProgram() {
-  makeContextCurrent();
-  return glCreateProgram();
+  localMakeContextCurrent();
+  return CALL_GL_IMPL(CreateProgram)();
 }
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::createRenderbuffer() {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLuint o;
-  glGenRenderbuffers(1, &o);
+  CALL_GL_IMPL(GenRenderbuffers)(1, &o);
   return o;
 }
 
 DELEGATE_TO_GL_1R(createShader, CreateShader, WGC3Denum, WebGLId);
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::createTexture() {
-  makeContextCurrent();
+  localMakeContextCurrent();
   GLuint o;
-  glGenTextures(1, &o);
+  CALL_GL_IMPL(GenTextures)(1, &o);
   return o;
 }
 
 void WebGraphicsContext3DCommandBufferImpl::deleteBuffer(WebGLId buffer) {
-  makeContextCurrent();
-  glDeleteBuffers(1, &buffer);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(DeleteBuffers)(1, &buffer);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::deleteFramebuffer(
     WebGLId framebuffer) {
-  makeContextCurrent();
-  glDeleteFramebuffers(1, &framebuffer);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(DeleteFramebuffers)(1, &framebuffer);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::deleteProgram(WebGLId program) {
-  makeContextCurrent();
-  glDeleteProgram(program);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(DeleteProgram)(program);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::deleteRenderbuffer(
     WebGLId renderbuffer) {
-  makeContextCurrent();
-  glDeleteRenderbuffers(1, &renderbuffer);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(DeleteRenderbuffers)(1, &renderbuffer);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::deleteShader(WebGLId shader) {
-  makeContextCurrent();
-  glDeleteShader(shader);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(DeleteShader)(shader);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::deleteTexture(WebGLId texture) {
-  makeContextCurrent();
-  glDeleteTextures(1, &texture);
+  localMakeContextCurrent();
+  CALL_GL_IMPL(DeleteTextures)(1, &texture);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::copyTextureToCompositor(
     WebGLId texture, WebGLId parentTexture) {
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::copyTextureToCompositor");
-  makeContextCurrent();
-  glCopyTextureToParentTextureCHROMIUM(texture, parentTexture);
-  glFlush();
+  localMakeContextCurrent();
+  CALL_GL_IMPL(CopyTextureToParentTextureCHROMIUM)(texture, parentTexture);
+  CALL_GL_IMPL(Flush)();
 }
 
 void WebGraphicsContext3DCommandBufferImpl::OnSwapBuffersComplete() {
   // This may be called after tear-down of the RenderView.
   RenderView* renderview =
       web_view_ ? RenderView::FromWebView(web_view_) : NULL;
   if (renderview)
     renderview->OnViewContextSwapBuffersComplete();
 }
 
 void WebGraphicsContext3DCommandBufferImpl::setContextLostCallback(
     WebGraphicsContext3D::WebGraphicsContextLostCallback* cb)
 {
   context_lost_callback_ = cb;
 }
 
 void WebGraphicsContext3DCommandBufferImpl::OnContextLost() {
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
 
   RenderView* renderview =
       web_view_ ? RenderView::FromWebView(web_view_) : NULL;
   if (renderview)
     renderview->OnViewContextSwapBuffersAborted();
 }
 
 #endif  // defined(ENABLE_GPU)