Virtual GL

BUG=155557


Review URL: https://chromiumcodereview.appspot.com/11275120

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@166442 0039d316-1c4b-4281-b951-d872f2087c98

22 files changed, 1159 insertions, 6 deletions

diff --git a/ui/gl/generate_bindings.py b/ui/gl/generate_bindings.py
index 3bf7b37..45041d8 100755
--- a/ui/gl/generate_bindings.py
+++ b/ui/gl/generate_bindings.py
@@ -1234,9 +1234,6 @@ def GenerateAPIHeader(file, functions, set_name, used_extension_functions):
 
 // This file is automatically generated.
 
-#ifndef UI_GFX_GL_GL_BINDINGS_API_AUTOGEN_%(name)s_H_
-#define UI_GFX_GL_GL_BINDINGS_API_AUTOGEN_%(name)s_H_
-
 """ % {'name': set_name.upper()})
 
   # Write API declaration.
@@ -1245,8 +1242,6 @@ def GenerateAPIHeader(file, functions, set_name, used_extension_functions):
       (func['return_type'], func['names'][0], func['arguments']))
 
   file.write('\n')
-  file.write('#endif  //  UI_GFX_GL_GL_BINDINGS_API_AUTOGEN_%s_H_\n' %
-      set_name.upper())
 
 
 def GenerateSource(file, functions, set_name, used_extension_functions):
diff --git a/ui/gl/gl.gyp b/ui/gl/gl.gyp
index 3d0ffb8..e330a15 100644
--- a/ui/gl/gl.gyp
+++ b/ui/gl/gl.gyp
@@ -75,6 +75,8 @@
         'gl_osmesa_api_implementation.h',
         'gl_share_group.cc',
         'gl_share_group.h',
+        'gl_state_restorer.cc',
+        'gl_state_restorer.h',
         'gl_surface.cc',
         'gl_surface.h',
         'gl_surface_android.cc',
@@ -92,6 +94,8 @@
         'gpu_switching_manager.h',
         'scoped_make_current.cc',
         'scoped_make_current.h',
+        'gl_state_restorer.cc',
+        'gl_state_restorer.h',
         '<(gl_binding_output_dir)/gl_bindings_autogen_gl.cc',
         '<(gl_binding_output_dir)/gl_bindings_autogen_gl.h',
         '<(gl_binding_output_dir)/gl_bindings_autogen_mock.cc',
diff --git a/ui/gl/gl_context.cc b/ui/gl/gl_context.cc
index b3a119c..a0433a6 100644
--- a/ui/gl/gl_context.cc
+++ b/ui/gl/gl_context.cc
@@ -10,6 +10,7 @@
 #include "base/threading/thread_local.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
@@ -87,6 +88,10 @@ void GLContext::SetCurrent(GLContext* context, GLSurface* surface) {
   GLSurface::SetCurrent(surface);
 }
 
+GLStateRestorer* GLContext::GetGLStateRestorer() {
+  return NULL;
+}
+
 bool GLContext::WasAllocatedUsingRobustnessExtension() {
   return false;
 }
@@ -102,4 +107,21 @@ bool GLContext::InitializeExtensionBindings() {
   return initialized;
 }
 
+void GLContext::SetupForVirtualization() {
+  if (!virtual_gl_api_) {
+    virtual_gl_api_.reset(new VirtualGLApi());
+    virtual_gl_api_->Initialize(&g_driver_gl, this);
+  }
+}
+
+bool GLContext::MakeVirtuallyCurrent(
+    GLContext* virtual_context, GLSurface* surface) {
+  DCHECK(virtual_gl_api_);
+  return virtual_gl_api_->MakeCurrent(virtual_context, surface);
+}
+
+void GLContext::SetRealGLApi() {
+  SetGLToRealGLApi();
+}
+
 }  // namespace gfx
diff --git a/ui/gl/gl_context.h b/ui/gl/gl_context.h
index 27a1a78..3648ba1 100644
--- a/ui/gl/gl_context.h
+++ b/ui/gl/gl_context.h
@@ -9,12 +9,15 @@
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gpu_preference.h"
 
 namespace gfx {
 
 class GLSurface;
+class VirtualGLApi;
+class GLStateRestorer;
 
 // Encapsulates an OpenGL context, hiding platform specific management.
 class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
@@ -44,6 +47,9 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
   // Get the underlying platform specific GL context "handle".
   virtual void* GetHandle() = 0;
 
+  // Gets the GLStateRestore for the context.
+  virtual GLStateRestorer* GetGLStateRestorer();
+
   // Set swap interval. This context must be current.
   virtual void SetSwapInterval(int interval) = 0;
 
@@ -75,8 +81,17 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
 
   virtual bool WasAllocatedUsingRobustnessExtension();
 
+  // Use this context for virtualization.
+  void SetupForVirtualization();
+
+  // Make this context current when used for context virtualization.
+  bool MakeVirtuallyCurrent(GLContext* virutal_context, GLSurface* surface);
+
  protected:
   virtual ~GLContext();
+
+  // Sets the GL api to the real hardware API (vs the VirtualAPI)
+  static void SetRealGLApi();
   static void SetCurrent(GLContext* context, GLSurface* surface);
 
   // Initialize function pointers to extension functions in the GL
@@ -88,6 +103,7 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
   friend class base::RefCounted<GLContext>;
 
   scoped_refptr<GLShareGroup> share_group_;
+  scoped_ptr<VirtualGLApi> virtual_gl_api_;
 
   DISALLOW_COPY_AND_ASSIGN(GLContext);
 };
diff --git a/ui/gl/gl_context_cgl.cc b/ui/gl/gl_context_cgl.cc
index 1bd4092..cdd84ba 100644
--- a/ui/gl/gl_context_cgl.cc
+++ b/ui/gl/gl_context_cgl.cc
@@ -125,6 +125,7 @@ bool GLContextCGL::MakeCurrent(GLSurface* surface) {
     return false;
   }
 
+  SetRealGLApi();
   return true;
 }
 
diff --git a/ui/gl/gl_context_egl.cc b/ui/gl/gl_context_egl.cc
index 6fd85b9..aa88048 100644
--- a/ui/gl/gl_context_egl.cc
+++ b/ui/gl/gl_context_egl.cc
@@ -120,6 +120,7 @@ bool GLContextEGL::MakeCurrent(GLSurface* surface) {
     return false;
   }
 
+  SetRealGLApi();
   return true;
 }
 
diff --git a/ui/gl/gl_context_glx.cc b/ui/gl/gl_context_glx.cc
index 3ab750b..f36a2bdc 100644
--- a/ui/gl/gl_context_glx.cc
+++ b/ui/gl/gl_context_glx.cc
@@ -179,6 +179,7 @@ bool GLContextGLX::MakeCurrent(GLSurface* surface) {
     return false;
   }
 
+  SetRealGLApi();
   return true;
 }
 
diff --git a/ui/gl/gl_context_osmesa.cc b/ui/gl/gl_context_osmesa.cc
index 445df87..a279177 100644
--- a/ui/gl/gl_context_osmesa.cc
+++ b/ui/gl/gl_context_osmesa.cc
@@ -76,6 +76,7 @@ bool GLContextOSMesa::MakeCurrent(GLSurface* surface) {
     return false;
   }
 
+  SetRealGLApi();
   return true;
 }
 
diff --git a/ui/gl/gl_context_stub.cc b/ui/gl/gl_context_stub.cc
index d1364c4..2b72c8f 100644
--- a/ui/gl/gl_context_stub.cc
+++ b/ui/gl/gl_context_stub.cc
@@ -17,6 +17,7 @@ void GLContextStub::Destroy() {}
 
 bool GLContextStub::MakeCurrent(GLSurface* surface) {
   SetCurrent(this, surface);
+  SetRealGLApi();
   return true;
 }
 
diff --git a/ui/gl/gl_context_wgl.cc b/ui/gl/gl_context_wgl.cc
index c136641..916e49d 100644
--- a/ui/gl/gl_context_wgl.cc
+++ b/ui/gl/gl_context_wgl.cc
@@ -92,6 +92,7 @@ bool GLContextWGL::MakeCurrent(GLSurface* surface) {
     return false;
   }
 
+  SetRealGLApi();
   return true;
 }
 
diff --git a/ui/gl/gl_egl_api_implementation.cc b/ui/gl/gl_egl_api_implementation.cc
index aa25ef4..26fe6b6 100644
--- a/ui/gl/gl_egl_api_implementation.cc
+++ b/ui/gl/gl_egl_api_implementation.cc
@@ -43,6 +43,9 @@ EGLApi::~EGLApi() {
 RealEGLApi::RealEGLApi() {
 }
 
+RealEGLApi::~RealEGLApi() {
+}
+
 void RealEGLApi::Initialize(DriverEGL* driver) {
   driver_ = driver;
 }
diff --git a/ui/gl/gl_egl_api_implementation.h b/ui/gl/gl_egl_api_implementation.h
index adb71d4..f0a75f4 100644
--- a/ui/gl/gl_egl_api_implementation.h
+++ b/ui/gl/gl_egl_api_implementation.h
@@ -21,6 +21,7 @@ void ClearGLBindingsEGL();
 class GL_EXPORT RealEGLApi : public EGLApi {
  public:
   RealEGLApi();
+  virtual ~RealEGLApi();
   void Initialize(DriverEGL* driver);
 
   // Include the auto-generated part of this class. We split this because
diff --git a/ui/gl/gl_gl_api_implementation.cc b/ui/gl/gl_gl_api_implementation.cc
index 0a6bf8c..c16ffab 100644
--- a/ui/gl/gl_gl_api_implementation.cc
+++ b/ui/gl/gl_gl_api_implementation.cc
@@ -4,6 +4,9 @@
 
 #include "ui/gl/gl_gl_api_implementation.h"
 
+#include "ui/gl/gl_context.h"
+#include "ui/gl/gl_state_restorer.h"
+
 namespace gfx {
 
 RealGLApi* g_real_gl;
@@ -14,7 +17,19 @@ void InitializeGLBindingsGL() {
     g_real_gl = new RealGLApi();
   }
   g_real_gl->Initialize(&g_driver_gl);
-  g_current_gl_context = g_real_gl;
+  SetGLToRealGLApi();
+}
+
+GLApi* GetCurrentGLApi() {
+  return g_current_gl_context;
+}
+
+void SetGLApi(GLApi* api) {
+  g_current_gl_context = api;
+}
+
+void SetGLToRealGLApi() {
+  SetGLApi(g_real_gl);
 }
 
 void InitializeGLExtensionBindingsGL(GLContext* context) {
@@ -43,10 +58,1006 @@ GLApi::~GLApi() {
 RealGLApi::RealGLApi() {
 }
 
+RealGLApi::~RealGLApi() {
+}
+
 void RealGLApi::Initialize(DriverGL* driver) {
   driver_ = driver;
 }
 
+VirtualGLApi::VirtualGLApi()
+    : driver_(NULL),
+      real_context_(NULL),
+      current_context_(NULL),
+      current_surface_(NULL) {
+}
+
+VirtualGLApi::~VirtualGLApi() {
+}
+
+void VirtualGLApi::Initialize(DriverGL* driver, GLContext* real_context) {
+  driver_ = driver;
+  real_context_ = real_context;
+}
+
+bool VirtualGLApi::MakeCurrent(GLContext* virtual_context, GLSurface* surface) {
+  bool switched_contexts = g_current_gl_context != this;
+  if (switched_contexts || surface != current_surface_) {
+    // TODO: Emit warning on Android?
+    if (!real_context_->MakeCurrent(surface)) {
+      return false;
+    }
+    current_surface_ = surface;
+  }
+  if (switched_contexts || virtual_context != current_context_) {
+    current_context_ = virtual_context;
+    // Set all state that is different from the real state
+    // NOTE: !!! This is a temporary implementation that just restores all
+    // state to let us test that it works.
+    // TODO: ASAP, change this to something that only restores the state
+    // needed for individual GL calls.
+    GLApi* temp = GetCurrentGLApi();
+    SetGLToRealGLApi();
+    virtual_context->GetGLStateRestorer()->RestoreState();
+    SetGLApi(temp);
+  }
+  SetGLApi(this);
+  return true;
+}
+
+void VirtualGLApi::glActiveTextureFn(GLenum texture) {
+  driver_->fn.glActiveTextureFn(texture);
+}
+
+void VirtualGLApi::glAttachShaderFn(GLuint program, GLuint shader) {
+  driver_->fn.glAttachShaderFn(program, shader);
+}
+
+void VirtualGLApi::glBeginQueryFn(GLenum target, GLuint id) {
+  driver_->fn.glBeginQueryFn(target, id);
+}
+
+void VirtualGLApi::glBeginQueryARBFn(GLenum target, GLuint id) {
+  driver_->fn.glBeginQueryARBFn(target, id);
+}
+
+void VirtualGLApi::glBindAttribLocationFn(
+    GLuint program, GLuint index, const char* name) {
+  driver_->fn.glBindAttribLocationFn(program, index, name);
+}
+
+void VirtualGLApi::glBindBufferFn(GLenum target, GLuint buffer) {
+  driver_->fn.glBindBufferFn(target, buffer);
+}
+
+void VirtualGLApi::glBindFragDataLocationFn(
+    GLuint program, GLuint colorNumber, const char* name) {
+  driver_->fn.glBindFragDataLocationFn(program, colorNumber, name);
+}
+
+void VirtualGLApi::glBindFragDataLocationIndexedFn(
+    GLuint program, GLuint colorNumber, GLuint index, const char* name) {
+  driver_->fn.glBindFragDataLocationIndexedFn(
+      program, colorNumber, index, name);
+}
+
+void VirtualGLApi::glBindFramebufferEXTFn(GLenum target, GLuint framebuffer) {
+  driver_->fn.glBindFramebufferEXTFn(target, framebuffer);
+}
+
+void VirtualGLApi::glBindRenderbufferEXTFn(GLenum target, GLuint renderbuffer) {
+  driver_->fn.glBindRenderbufferEXTFn(target, renderbuffer);
+}
+
+void VirtualGLApi::glBindTextureFn(GLenum target, GLuint texture) {
+  driver_->fn.glBindTextureFn(target, texture);
+}
+
+void VirtualGLApi::glBlendColorFn(
+    GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
+  driver_->fn.glBlendColorFn(red, green, blue, alpha);
+}
+
+void VirtualGLApi::glBlendEquationFn( GLenum mode ) {
+  driver_->fn.glBlendEquationFn( mode );
+}
+
+void VirtualGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) {
+  driver_->fn.glBlendEquationSeparateFn(modeRGB, modeAlpha);
+}
+
+void VirtualGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) {
+  driver_->fn.glBlendFuncFn(sfactor, dfactor);
+}
+
+void VirtualGLApi::glBlendFuncSeparateFn(
+    GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
+  driver_->fn.glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void VirtualGLApi::glBlitFramebufferEXTFn(
+    GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+    GLbitfield mask, GLenum filter) {
+  driver_->fn.glBlitFramebufferEXTFn(
+      srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+}
+
+void VirtualGLApi::glBlitFramebufferANGLEFn(
+    GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+    GLbitfield mask, GLenum filter) {
+  driver_->fn.glBlitFramebufferANGLEFn(
+      srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+}
+
+void VirtualGLApi::glBufferDataFn(
+    GLenum target, GLsizei size, const void* data, GLenum usage) {
+  driver_->fn.glBufferDataFn(target, size, data, usage);
+}
+
+void VirtualGLApi::glBufferSubDataFn(
+    GLenum target, GLint offset, GLsizei size, const void* data) {
+  driver_->fn.glBufferSubDataFn(target, offset, size, data);
+}
+
+GLenum VirtualGLApi::glCheckFramebufferStatusEXTFn(GLenum target) {
+  return driver_->fn.glCheckFramebufferStatusEXTFn(target);
+}
+
+void VirtualGLApi::glClearFn(GLbitfield mask) {
+  driver_->fn.glClearFn(mask);
+}
+
+void VirtualGLApi::glClearColorFn(
+    GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
+  driver_->fn.glClearColorFn(red, green, blue, alpha);
+}
+
+void VirtualGLApi::glClearDepthFn(GLclampd depth) {
+  driver_->fn.glClearDepthFn(depth);
+}
+
+void VirtualGLApi::glClearDepthfFn(GLclampf depth) {
+  driver_->fn.glClearDepthfFn(depth);
+}
+
+void VirtualGLApi::glClearStencilFn(GLint s) {
+  driver_->fn.glClearStencilFn(s);
+}
+
+void VirtualGLApi::glColorMaskFn(
+    GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
+  driver_->fn.glColorMaskFn(red, green, blue, alpha);
+}
+
+void VirtualGLApi::glCompileShaderFn(GLuint shader) {
+  driver_->fn.glCompileShaderFn(shader);
+}
+
+void VirtualGLApi::glCompressedTexImage2DFn(
+    GLenum target, GLint level, GLenum internalformat,
+    GLsizei width, GLsizei height, GLint border,
+    GLsizei imageSize, const void* data) {
+  driver_->fn.glCompressedTexImage2DFn(
+      target, level, internalformat, width, height, border, imageSize, data);
+}
+
+void VirtualGLApi::glCompressedTexSubImage2DFn(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset,
+    GLsizei width, GLsizei height, GLenum format,
+    GLsizei imageSize, const void* data) {
+  driver_->fn.glCompressedTexSubImage2DFn(
+      target, level, xoffset, yoffset, width, height, format, imageSize, data);
+}
+
+void VirtualGLApi::glCopyTexImage2DFn(
+    GLenum target, GLint level, GLenum internalformat,
+    GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
+  driver_->fn.glCopyTexImage2DFn(
+      target, level, internalformat, x, y, width, height, border);
+}
+
+void VirtualGLApi::glCopyTexSubImage2DFn(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset,
+    GLint x, GLint y, GLsizei width, GLsizei height) {
+  driver_->fn.glCopyTexSubImage2DFn(
+      target, level, xoffset, yoffset, x, y, width, height);
+}
+
+GLuint VirtualGLApi::glCreateProgramFn(void) {
+  return driver_->fn.glCreateProgramFn();
+}
+
+GLuint VirtualGLApi::glCreateShaderFn(GLenum type) {
+  return driver_->fn.glCreateShaderFn(type);
+}
+
+void VirtualGLApi::glCullFaceFn(GLenum mode) {
+  driver_->fn.glCullFaceFn(mode);
+}
+
+void VirtualGLApi::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
+  driver_->fn.glDeleteBuffersARBFn(n, buffers);
+}
+
+void VirtualGLApi::glDeleteFramebuffersEXTFn(
+    GLsizei n, const GLuint* framebuffers) {
+  driver_->fn.glDeleteFramebuffersEXTFn(n, framebuffers);
+}
+
+void VirtualGLApi::glDeleteProgramFn(GLuint program) {
+  driver_->fn.glDeleteProgramFn(program);
+}
+
+void VirtualGLApi::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
+  driver_->fn.glDeleteQueriesFn(n, ids);
+}
+
+void VirtualGLApi::glDeleteQueriesARBFn(GLsizei n, const GLuint* ids) {
+  driver_->fn.glDeleteQueriesARBFn(n, ids);
+}
+
+void VirtualGLApi::glDeleteRenderbuffersEXTFn(
+    GLsizei n, const GLuint* renderbuffers) {
+  driver_->fn.glDeleteRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void VirtualGLApi::glDeleteShaderFn(GLuint shader) {
+  driver_->fn.glDeleteShaderFn(shader);
+}
+
+void VirtualGLApi::glDeleteTexturesFn(GLsizei n, const GLuint* textures) {
+  driver_->fn.glDeleteTexturesFn(n, textures);
+}
+
+void VirtualGLApi::glDepthFuncFn(GLenum func) {
+  driver_->fn.glDepthFuncFn(func);
+}
+
+void VirtualGLApi::glDepthMaskFn(GLboolean flag) {
+  driver_->fn.glDepthMaskFn(flag);
+}
+
+void VirtualGLApi::glDepthRangeFn(GLclampd zNear, GLclampd zFar) {
+  driver_->fn.glDepthRangeFn(zNear, zFar);
+}
+
+void VirtualGLApi::glDepthRangefFn(GLclampf zNear, GLclampf zFar) {
+  driver_->fn.glDepthRangefFn(zNear, zFar);
+}
+
+void VirtualGLApi::glDetachShaderFn(GLuint program, GLuint shader) {
+  driver_->fn.glDetachShaderFn(program, shader);
+}
+
+void VirtualGLApi::glDisableFn(GLenum cap) {
+  driver_->fn.glDisableFn(cap);
+}
+
+void VirtualGLApi::glDisableVertexAttribArrayFn(GLuint index) {
+  driver_->fn.glDisableVertexAttribArrayFn(index);
+}
+
+void VirtualGLApi::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
+  driver_->fn.glDrawArraysFn(mode, first, count);
+}
+
+void VirtualGLApi::glDrawBufferFn(GLenum mode) {
+  driver_->fn.glDrawBufferFn(mode);
+}
+
+void VirtualGLApi::glDrawBuffersARBFn(GLsizei n, const GLenum* bufs) {
+  driver_->fn.glDrawBuffersARBFn(n, bufs);
+}
+
+void VirtualGLApi::glDrawElementsFn(
+    GLenum mode, GLsizei count, GLenum type, const void* indices) {
+  driver_->fn.glDrawElementsFn(mode, count, type, indices);
+}
+
+void VirtualGLApi::glEGLImageTargetTexture2DOESFn(
+    GLenum target, GLeglImageOES image) {
+  driver_->fn.glEGLImageTargetTexture2DOESFn(target, image);
+}
+
+void VirtualGLApi::glEGLImageTargetRenderbufferStorageOESFn(
+    GLenum target, GLeglImageOES image) {
+  driver_->fn.glEGLImageTargetRenderbufferStorageOESFn(target, image);
+}
+
+void VirtualGLApi::glEnableFn(GLenum cap) {
+  driver_->fn.glEnableFn(cap);
+}
+
+void VirtualGLApi::glEnableVertexAttribArrayFn(GLuint index) {
+  driver_->fn.glEnableVertexAttribArrayFn(index);
+}
+
+void VirtualGLApi::glEndQueryFn(GLenum target) {
+  driver_->fn.glEndQueryFn(target);
+}
+
+void VirtualGLApi::glEndQueryARBFn(GLenum target) {
+  driver_->fn.glEndQueryARBFn(target);
+}
+
+void VirtualGLApi::glFinishFn(void) {
+  driver_->fn.glFinishFn();
+}
+
+void VirtualGLApi::glFlushFn(void) {
+  driver_->fn.glFlushFn();
+}
+
+void VirtualGLApi::glFramebufferRenderbufferEXTFn(
+    GLenum target, GLenum attachment,
+    GLenum renderbuffertarget, GLuint renderbuffer) {
+  driver_->fn.glFramebufferRenderbufferEXTFn(
+      target, attachment, renderbuffertarget, renderbuffer);
+}
+
+void VirtualGLApi::glFramebufferTexture2DEXTFn(
+    GLenum target, GLenum attachment,
+    GLenum textarget, GLuint texture, GLint level) {
+  driver_->fn.glFramebufferTexture2DEXTFn(
+      target, attachment, textarget, texture, level);
+}
+
+void VirtualGLApi::glFrontFaceFn(GLenum mode) {
+  driver_->fn.glFrontFaceFn(mode);
+}
+
+void VirtualGLApi::glGenBuffersARBFn(GLsizei n, GLuint* buffers) {
+  driver_->fn.glGenBuffersARBFn(n, buffers);
+}
+
+void VirtualGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
+  driver_->fn.glGenQueriesFn(n, ids);
+}
+
+void VirtualGLApi::glGenQueriesARBFn(GLsizei n, GLuint* ids) {
+  driver_->fn.glGenQueriesARBFn(n, ids);
+}
+
+void VirtualGLApi::glGenerateMipmapEXTFn(GLenum target) {
+  driver_->fn.glGenerateMipmapEXTFn(target);
+}
+
+void VirtualGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
+  driver_->fn.glGenFramebuffersEXTFn(n, framebuffers);
+}
+
+void VirtualGLApi::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
+  driver_->fn.glGenRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void VirtualGLApi::glGenTexturesFn(GLsizei n, GLuint* textures) {
+  driver_->fn.glGenTexturesFn(n, textures);
+}
+
+void VirtualGLApi::glGetActiveAttribFn(
+    GLuint program, GLuint index, GLsizei bufsize,
+    GLsizei* length, GLint* size, GLenum* type, char* name) {
+  driver_->fn.glGetActiveAttribFn(
+      program, index, bufsize, length, size, type, name);
+}
+
+void VirtualGLApi::glGetActiveUniformFn(
+    GLuint program, GLuint index, GLsizei bufsize,
+    GLsizei* length, GLint* size, GLenum* type, char* name) {
+  driver_->fn.glGetActiveUniformFn(
+      program, index, bufsize, length, size, type, name);
+}
+
+void VirtualGLApi::glGetAttachedShadersFn(
+    GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
+  driver_->fn.glGetAttachedShadersFn(program, maxcount, count, shaders);
+}
+
+GLint VirtualGLApi::glGetAttribLocationFn(GLuint program, const char* name) {
+  return driver_->fn.glGetAttribLocationFn(program, name);
+}
+
+void VirtualGLApi::glGetBooleanvFn(GLenum pname, GLboolean* params) {
+  driver_->fn.glGetBooleanvFn(pname, params);
+}
+
+void VirtualGLApi::glGetBufferParameterivFn(
+    GLenum target, GLenum pname, GLint* params) {
+  driver_->fn.glGetBufferParameterivFn(target, pname, params);
+}
+
+GLenum VirtualGLApi::glGetErrorFn(void) {
+  return driver_->fn.glGetErrorFn();
+}
+
+void VirtualGLApi::glGetFloatvFn(GLenum pname, GLfloat* params) {
+  driver_->fn.glGetFloatvFn(pname, params);
+}
+
+void VirtualGLApi::glGetFramebufferAttachmentParameterivEXTFn(
+    GLenum target, GLenum attachment, GLenum pname, GLint* params) {
+  driver_->fn.glGetFramebufferAttachmentParameterivEXTFn(
+      target, attachment, pname, params);
+}
+
+GLenum VirtualGLApi::glGetGraphicsResetStatusARBFn(void) {
+  return driver_->fn.glGetGraphicsResetStatusARBFn();
+}
+
+void VirtualGLApi::glGetIntegervFn(GLenum pname, GLint* params) {
+  driver_->fn.glGetIntegervFn(pname, params);
+}
+
+void VirtualGLApi::glGetProgramBinaryFn(
+    GLuint program, GLsizei bufSize,
+    GLsizei* length, GLenum* binaryFormat, GLvoid* binary) {
+  driver_->fn.glGetProgramBinaryFn(
+      program, bufSize, length, binaryFormat, binary);
+}
+
+void VirtualGLApi::glGetProgramivFn(
+    GLuint program, GLenum pname, GLint* params) {
+  driver_->fn.glGetProgramivFn(program, pname, params);
+}
+
+void VirtualGLApi::glGetProgramInfoLogFn(
+    GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) {
+  driver_->fn.glGetProgramInfoLogFn(program, bufsize, length, infolog);
+}
+
+void VirtualGLApi::glGetQueryivFn(GLenum target, GLenum pname, GLint* params) {
+  driver_->fn.glGetQueryivFn(target, pname, params);
+}
+
+void VirtualGLApi::glGetQueryivARBFn(
+    GLenum target, GLenum pname, GLint* params) {
+  driver_->fn.glGetQueryivARBFn(target, pname, params);
+}
+
+void VirtualGLApi::glGetQueryObjecti64vFn(
+    GLuint id, GLenum pname, GLint64* params) {
+  driver_->fn.glGetQueryObjecti64vFn(id, pname, params);
+}
+
+void VirtualGLApi::glGetQueryObjectivFn(
+    GLuint id, GLenum pname, GLint* params) {
+  driver_->fn.glGetQueryObjectivFn(id, pname, params);
+}
+
+void VirtualGLApi::glGetQueryObjectui64vFn(
+    GLuint id, GLenum pname, GLuint64* params) {
+  driver_->fn.glGetQueryObjectui64vFn(id, pname, params);
+}
+
+void VirtualGLApi::glGetQueryObjectuivFn(
+    GLuint id, GLenum pname, GLuint* params) {
+  driver_->fn.glGetQueryObjectuivFn(id, pname, params);
+}
+
+void VirtualGLApi::glGetQueryObjectuivARBFn(
+    GLuint id, GLenum pname, GLuint* params) {
+  driver_->fn.glGetQueryObjectuivARBFn(id, pname, params);
+}
+
+void VirtualGLApi::glGetRenderbufferParameterivEXTFn(
+    GLenum target, GLenum pname, GLint* params) {
+  driver_->fn.glGetRenderbufferParameterivEXTFn(target, pname, params);
+}
+
+void VirtualGLApi::glGetShaderivFn(GLuint shader, GLenum pname, GLint* params) {
+  driver_->fn.glGetShaderivFn(shader, pname, params);
+}
+
+void VirtualGLApi::glGetShaderInfoLogFn(
+    GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) {
+  driver_->fn.glGetShaderInfoLogFn(shader, bufsize, length, infolog);
+}
+
+void VirtualGLApi::glGetShaderPrecisionFormatFn(
+    GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
+  driver_->fn.glGetShaderPrecisionFormatFn(
+      shadertype, precisiontype, range, precision);
+}
+
+void VirtualGLApi::glGetShaderSourceFn(
+    GLuint shader, GLsizei bufsize, GLsizei* length, char* source) {
+  driver_->fn.glGetShaderSourceFn(shader, bufsize, length, source);
+}
+
+const GLubyte* VirtualGLApi::glGetStringFn(GLenum name) {
+  switch (name) {
+    case GL_EXTENSIONS:
+      // For now return no extensions.
+      //
+      // Specificially we can't support GL_EXT_occlusion_query_boolean which is
+      // based on GL_ARB_occlusion_query without a lot of work virtualizing
+      // queries.
+      //
+      // Also we don't support multisample yet, nor vertex array objects,
+      // etc..
+      //
+      // We can turn on other extensions on an as needed basis. For now, if you
+      // need the extensions, don't make a virtual context.
+      return reinterpret_cast<const GLubyte*>("");
+    default:
+      return driver_->fn.glGetStringFn(name);
+  }
+}
+
+void VirtualGLApi::glGetTexLevelParameterfvFn(
+    GLenum target, GLint level, GLenum pname, GLfloat* params) {
+  driver_->fn.glGetTexLevelParameterfvFn(target, level, pname, params);
+}
+
+void VirtualGLApi::glGetTexLevelParameterivFn(
+    GLenum target, GLint level, GLenum pname, GLint* params) {
+  driver_->fn.glGetTexLevelParameterivFn(target, level, pname, params);
+}
+
+void VirtualGLApi::glGetTexParameterfvFn(
+    GLenum target, GLenum pname, GLfloat* params) {
+  driver_->fn.glGetTexParameterfvFn(target, pname, params);
+}
+
+void VirtualGLApi::glGetTexParameterivFn(
+    GLenum target, GLenum pname, GLint* params) {
+  driver_->fn.glGetTexParameterivFn(target, pname, params);
+}
+
+void VirtualGLApi::glGetTranslatedShaderSourceANGLEFn(
+    GLuint shader, GLsizei bufsize, GLsizei* length, char* source) {
+  driver_->fn.glGetTranslatedShaderSourceANGLEFn(
+      shader, bufsize, length, source);
+}
+
+void VirtualGLApi::glGetUniformfvFn(
+    GLuint program, GLint location, GLfloat* params) {
+  driver_->fn.glGetUniformfvFn(program, location, params);
+}
+
+void VirtualGLApi::glGetUniformivFn(
+    GLuint program, GLint location, GLint* params) {
+  driver_->fn.glGetUniformivFn(program, location, params);
+}
+
+GLint VirtualGLApi::glGetUniformLocationFn(GLuint program, const char* name) {
+  return driver_->fn.glGetUniformLocationFn(program, name);
+}
+
+void VirtualGLApi::glGetVertexAttribfvFn(
+    GLuint index, GLenum pname, GLfloat* params) {
+  driver_->fn.glGetVertexAttribfvFn(index, pname, params);
+}
+
+void VirtualGLApi::glGetVertexAttribivFn(
+    GLuint index, GLenum pname, GLint* params) {
+  driver_->fn.glGetVertexAttribivFn(index, pname, params);
+}
+
+void VirtualGLApi::glGetVertexAttribPointervFn(
+    GLuint index, GLenum pname, void** pointer) {
+  driver_->fn.glGetVertexAttribPointervFn(index, pname, pointer);
+}
+
+void VirtualGLApi::glHintFn(GLenum target, GLenum mode) {
+  driver_->fn.glHintFn(target, mode);
+}
+
+GLboolean VirtualGLApi::glIsBufferFn(GLuint buffer) {
+  return driver_->fn.glIsBufferFn(buffer);
+}
+
+GLboolean VirtualGLApi::glIsEnabledFn(GLenum cap) {
+  return driver_->fn.glIsEnabledFn(cap);
+}
+
+GLboolean VirtualGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
+  return driver_->fn.glIsFramebufferEXTFn(framebuffer);
+}
+
+GLboolean VirtualGLApi::glIsProgramFn(GLuint program) {
+  return driver_->fn.glIsProgramFn(program);
+}
+
+GLboolean VirtualGLApi::glIsQueryARBFn(GLuint query) {
+  return driver_->fn.glIsQueryARBFn(query);
+}
+
+GLboolean VirtualGLApi::glIsRenderbufferEXTFn(GLuint renderbuffer) {
+  return driver_->fn.glIsRenderbufferEXTFn(renderbuffer);
+}
+
+GLboolean VirtualGLApi::glIsShaderFn(GLuint shader) {
+  return driver_->fn.glIsShaderFn(shader);
+}
+
+GLboolean VirtualGLApi::glIsTextureFn(GLuint texture) {
+  return driver_->fn.glIsTextureFn(texture);
+}
+
+void VirtualGLApi::glLineWidthFn(GLfloat width) {
+  driver_->fn.glLineWidthFn(width);
+}
+
+void VirtualGLApi::glLinkProgramFn(GLuint program) {
+  driver_->fn.glLinkProgramFn(program);
+}
+
+void* VirtualGLApi::glMapBufferFn(GLenum target, GLenum access) {
+  return driver_->fn.glMapBufferFn(target, access);
+}
+
+void VirtualGLApi::glPixelStoreiFn(GLenum pname, GLint param) {
+  driver_->fn.glPixelStoreiFn(pname, param);
+}
+
+void VirtualGLApi::glPointParameteriFn(GLenum pname, GLint param) {
+  driver_->fn.glPointParameteriFn(pname, param);
+}
+
+void VirtualGLApi::glPolygonOffsetFn(GLfloat factor, GLfloat units) {
+  driver_->fn.glPolygonOffsetFn(factor, units);
+}
+
+void VirtualGLApi::glProgramBinaryFn(
+    GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) {
+  driver_->fn.glProgramBinaryFn(program, binaryFormat, binary, length);
+}
+
+void VirtualGLApi::glProgramParameteriFn(
+    GLuint program, GLenum pname, GLint value) {
+  driver_->fn.glProgramParameteriFn(program, pname, value);
+}
+
+void VirtualGLApi::glQueryCounterFn(GLuint id, GLenum target) {
+  driver_->fn.glQueryCounterFn(id, target);
+}
+
+void VirtualGLApi::glReadBufferFn(GLenum src) {
+  driver_->fn.glReadBufferFn(src);
+}
+
+void VirtualGLApi::glReadPixelsFn(
+    GLint x, GLint y, GLsizei width, GLsizei height,
+    GLenum format, GLenum type, void* pixels) {
+  driver_->fn.glReadPixelsFn(x, y, width, height, format, type, pixels);
+}
+
+void VirtualGLApi::glReleaseShaderCompilerFn(void) {
+  driver_->fn.glReleaseShaderCompilerFn();
+}
+
+void VirtualGLApi::glRenderbufferStorageMultisampleEXTFn(
+    GLenum target, GLsizei samples, GLenum internalformat,
+    GLsizei width, GLsizei height) {
+  driver_->fn.glRenderbufferStorageMultisampleEXTFn(
+      target, samples, internalformat, width, height);
+}
+
+void VirtualGLApi::glRenderbufferStorageMultisampleANGLEFn(
+    GLenum target, GLsizei samples, GLenum internalformat,
+    GLsizei width, GLsizei height) {
+  driver_->fn.glRenderbufferStorageMultisampleANGLEFn(
+      target, samples, internalformat, width, height);
+}
+
+void VirtualGLApi::glRenderbufferStorageEXTFn(
+    GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
+  driver_->fn.glRenderbufferStorageEXTFn(target, internalformat, width, height);
+}
+
+void VirtualGLApi::glSampleCoverageFn(GLclampf value, GLboolean invert) {
+  driver_->fn.glSampleCoverageFn(value, invert);
+}
+
+void VirtualGLApi::glScissorFn(
+    GLint x, GLint y, GLsizei width, GLsizei height) {
+  driver_->fn.glScissorFn(x, y, width, height);
+}
+
+void VirtualGLApi::glShaderBinaryFn(
+    GLsizei n, const GLuint* shaders, GLenum binaryformat,
+    const void* binary, GLsizei length) {
+  driver_->fn.glShaderBinaryFn(n, shaders, binaryformat, binary, length);
+}
+
+void VirtualGLApi::glShaderSourceFn(
+    GLuint shader, GLsizei count, const char** str, const GLint* length) {
+  driver_->fn.glShaderSourceFn(shader, count, str, length);
+}
+
+void VirtualGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
+  driver_->fn.glStencilFuncFn(func, ref, mask);
+}
+
+void VirtualGLApi::glStencilFuncSeparateFn(
+    GLenum face, GLenum func, GLint ref, GLuint mask) {
+  driver_->fn.glStencilFuncSeparateFn(face, func, ref, mask);
+}
+
+void VirtualGLApi::glStencilMaskFn(GLuint mask) {
+  driver_->fn.glStencilMaskFn(mask);
+}
+
+void VirtualGLApi::glStencilMaskSeparateFn(GLenum face, GLuint mask) {
+  driver_->fn.glStencilMaskSeparateFn(face, mask);
+}
+
+void VirtualGLApi::glStencilOpFn(GLenum fail, GLenum zfail, GLenum zpass) {
+  driver_->fn.glStencilOpFn(fail, zfail, zpass);
+}
+
+void VirtualGLApi::glStencilOpSeparateFn(
+    GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
+  driver_->fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
+}
+
+void VirtualGLApi::glTexImage2DFn(
+    GLenum target, GLint level, GLint internalformat,
+    GLsizei width, GLsizei height,
+    GLint border, GLenum format, GLenum type, const void* pixels) {
+  driver_->fn.glTexImage2DFn(
+      target, level, internalformat, width, height,
+      border, format, type, pixels);
+}
+
+void VirtualGLApi::glTexParameterfFn(
+    GLenum target, GLenum pname, GLfloat param) {
+  driver_->fn.glTexParameterfFn(target, pname, param);
+}
+
+void VirtualGLApi::glTexParameterfvFn(
+    GLenum target, GLenum pname, const GLfloat* params) {
+  driver_->fn.glTexParameterfvFn(target, pname, params);
+}
+
+void VirtualGLApi::glTexParameteriFn(GLenum target, GLenum pname, GLint param) {
+  driver_->fn.glTexParameteriFn(target, pname, param);
+}
+
+void VirtualGLApi::glTexParameterivFn(
+    GLenum target, GLenum pname, const GLint* params) {
+  driver_->fn.glTexParameterivFn(target, pname, params);
+}
+
+void VirtualGLApi::glTexStorage2DEXTFn(
+    GLenum target, GLsizei levels, GLenum internalformat,
+    GLsizei width, GLsizei height) {
+  driver_->fn.glTexStorage2DEXTFn(
+      target, levels, internalformat, width, height);
+}
+
+void VirtualGLApi::glTexSubImage2DFn(
+    GLenum target, GLint level, GLint xoffset, GLint yoffset,
+    GLsizei width, GLsizei height, GLenum format, GLenum type,
+    const void* pixels) {
+  driver_->fn.glTexSubImage2DFn(
+      target, level, xoffset, yoffset, width, height, format, type, pixels);
+}
+
+void VirtualGLApi::glUniform1fFn(GLint location, GLfloat x) {
+  driver_->fn.glUniform1fFn(location, x);
+}
+
+void VirtualGLApi::glUniform1fvFn(
+    GLint location, GLsizei count, const GLfloat* v) {
+  driver_->fn.glUniform1fvFn(location, count, v);
+}
+
+void VirtualGLApi::glUniform1iFn(GLint location, GLint x) {
+  driver_->fn.glUniform1iFn(location, x);
+}
+
+void VirtualGLApi::glUniform1ivFn(
+    GLint location, GLsizei count, const GLint* v) {
+  driver_->fn.glUniform1ivFn(location, count, v);
+}
+
+void VirtualGLApi::glUniform2fFn(GLint location, GLfloat x, GLfloat y) {
+  driver_->fn.glUniform2fFn(location, x, y);
+}
+
+void VirtualGLApi::glUniform2fvFn(
+    GLint location, GLsizei count, const GLfloat* v) {
+  driver_->fn.glUniform2fvFn(location, count, v);
+}
+
+void VirtualGLApi::glUniform2iFn(GLint location, GLint x, GLint y) {
+  driver_->fn.glUniform2iFn(location, x, y);
+}
+
+void VirtualGLApi::glUniform2ivFn(
+    GLint location, GLsizei count, const GLint* v) {
+  driver_->fn.glUniform2ivFn(location, count, v);
+}
+
+void VirtualGLApi::glUniform3fFn(
+    GLint location, GLfloat x, GLfloat y, GLfloat z) {
+  driver_->fn.glUniform3fFn(location, x, y, z);
+}
+
+void VirtualGLApi::glUniform3fvFn(
+    GLint location, GLsizei count, const GLfloat* v) {
+  driver_->fn.glUniform3fvFn(location, count, v);
+}
+
+void VirtualGLApi::glUniform3iFn(GLint location, GLint x, GLint y, GLint z) {
+  driver_->fn.glUniform3iFn(location, x, y, z);
+}
+
+void VirtualGLApi::glUniform3ivFn(
+    GLint location, GLsizei count, const GLint* v) {
+  driver_->fn.glUniform3ivFn(location, count, v);
+}
+
+void VirtualGLApi::glUniform4fFn(
+    GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
+  driver_->fn.glUniform4fFn(location, x, y, z, w);
+}
+
+void VirtualGLApi::glUniform4fvFn(
+    GLint location, GLsizei count, const GLfloat* v) {
+  driver_->fn.glUniform4fvFn(location, count, v);
+}
+
+void VirtualGLApi::glUniform4iFn(
+    GLint location, GLint x, GLint y, GLint z, GLint w) {
+  driver_->fn.glUniform4iFn(location, x, y, z, w);
+}
+
+void VirtualGLApi::glUniform4ivFn(
+    GLint location, GLsizei count, const GLint* v) {
+  driver_->fn.glUniform4ivFn(location, count, v);
+}
+
+void VirtualGLApi::glUniformMatrix2fvFn(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+  driver_->fn.glUniformMatrix2fvFn(location, count, transpose, value);
+}
+
+void VirtualGLApi::glUniformMatrix3fvFn(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+  driver_->fn.glUniformMatrix3fvFn(location, count, transpose, value);
+}
+
+void VirtualGLApi::glUniformMatrix4fvFn(
+    GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+  driver_->fn.glUniformMatrix4fvFn(location, count, transpose, value);
+}
+
+GLboolean VirtualGLApi::glUnmapBufferFn(GLenum target) {
+  return driver_->fn.glUnmapBufferFn(target);
+}
+
+void VirtualGLApi::glUseProgramFn(GLuint program) {
+  driver_->fn.glUseProgramFn(program);
+}
+
+void VirtualGLApi::glValidateProgramFn(GLuint program) {
+  driver_->fn.glValidateProgramFn(program);
+}
+
+void VirtualGLApi::glVertexAttrib1fFn(GLuint indx, GLfloat x) {
+  driver_->fn.glVertexAttrib1fFn(indx, x);
+}
+
+void VirtualGLApi::glVertexAttrib1fvFn(GLuint indx, const GLfloat* values) {
+  driver_->fn.glVertexAttrib1fvFn(indx, values);
+}
+
+void VirtualGLApi::glVertexAttrib2fFn(GLuint indx, GLfloat x, GLfloat y) {
+  driver_->fn.glVertexAttrib2fFn(indx, x, y);
+}
+
+void VirtualGLApi::glVertexAttrib2fvFn(GLuint indx, const GLfloat* values) {
+  driver_->fn.glVertexAttrib2fvFn(indx, values);
+}
+
+void VirtualGLApi::glVertexAttrib3fFn(
+    GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
+  driver_->fn.glVertexAttrib3fFn(indx, x, y, z);
+}
+
+void VirtualGLApi::glVertexAttrib3fvFn(GLuint indx, const GLfloat* values) {
+  driver_->fn.glVertexAttrib3fvFn(indx, values);
+}
+
+void VirtualGLApi::glVertexAttrib4fFn(
+    GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
+  driver_->fn.glVertexAttrib4fFn(indx, x, y, z, w);
+}
+
+void VirtualGLApi::glVertexAttrib4fvFn(GLuint indx, const GLfloat* values) {
+  driver_->fn.glVertexAttrib4fvFn(indx, values);
+}
+
+void VirtualGLApi::glVertexAttribPointerFn(
+    GLuint indx, GLint size, GLenum type, GLboolean normalized,
+    GLsizei stride, const void* ptr) {
+  driver_->fn.glVertexAttribPointerFn(
+      indx, size, type, normalized, stride, ptr);
+}
+
+void VirtualGLApi::glViewportFn(
+    GLint x, GLint y, GLsizei width, GLsizei height) {
+  driver_->fn.glViewportFn(x, y, width, height);
+}
+
+void VirtualGLApi::glGenFencesNVFn(GLsizei n, GLuint* fences) {
+  driver_->fn.glGenFencesNVFn(n, fences);
+}
+
+void VirtualGLApi::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
+  driver_->fn.glDeleteFencesNVFn(n, fences);
+}
+
+void VirtualGLApi::glSetFenceNVFn(GLuint fence, GLenum condition) {
+  driver_->fn.glSetFenceNVFn(fence, condition);
+}
+
+GLboolean VirtualGLApi::glTestFenceNVFn(GLuint fence) {
+  return driver_->fn.glTestFenceNVFn(fence);
+}
+
+void VirtualGLApi::glFinishFenceNVFn(GLuint fence) {
+  driver_->fn.glFinishFenceNVFn(fence);
+}
+
+GLboolean VirtualGLApi::glIsFenceNVFn(GLuint fence) {
+  return driver_->fn.glIsFenceNVFn(fence);
+}
+
+void VirtualGLApi::glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) {
+  driver_->fn.glGetFenceivNVFn(fence, pname, params);
+}
+
+GLsync VirtualGLApi::glFenceSyncFn(GLenum condition, GLbitfield flags) {
+  return driver_->fn.glFenceSyncFn(condition, flags);
+}
+
+void VirtualGLApi::glDeleteSyncFn(GLsync sync) {
+  driver_->fn.glDeleteSyncFn(sync);
+}
+
+void VirtualGLApi::glGetSyncivFn(
+    GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length,GLint* values) {
+  driver_->fn.glGetSyncivFn(sync, pname, bufSize, length,values);
+}
+
+void VirtualGLApi::glDrawArraysInstancedANGLEFn(
+    GLenum mode, GLint first, GLsizei count, GLsizei primcount) {
+  driver_->fn.glDrawArraysInstancedANGLEFn(mode, first, count, primcount);
+}
+
+void VirtualGLApi::glDrawElementsInstancedANGLEFn(
+    GLenum mode, GLsizei count, GLenum type, const void* indices,
+    GLsizei primcount) {
+  driver_->fn.glDrawElementsInstancedANGLEFn(
+      mode, count, type, indices, primcount);
+}
+
+void VirtualGLApi::glVertexAttribDivisorANGLEFn(GLuint index, GLuint divisor) {
+  driver_->fn.glVertexAttribDivisorANGLEFn(index, divisor);
+}
+
+void VirtualGLApi::glGenVertexArraysOESFn(GLsizei n, GLuint* arrays) {
+  driver_->fn.glGenVertexArraysOESFn(n, arrays);
+}
+
+void VirtualGLApi::glDeleteVertexArraysOESFn(GLsizei n, const GLuint* arrays) {
+  driver_->fn.glDeleteVertexArraysOESFn(n, arrays);
+}
+
+void VirtualGLApi::glBindVertexArrayOESFn(GLuint array) {
+  driver_->fn.glBindVertexArrayOESFn(array);
+}
+
+GLboolean VirtualGLApi::glIsVertexArrayOESFn(GLuint array) {
+  return driver_->fn.glIsVertexArrayOESFn(array);
+}
+
 }  // namespace gfx
 
 
diff --git a/ui/gl/gl_gl_api_implementation.h b/ui/gl/gl_gl_api_implementation.h
index 5c70b38c..5051bf3 100644
--- a/ui/gl/gl_gl_api_implementation.h
+++ b/ui/gl/gl_gl_api_implementation.h
@@ -9,18 +9,28 @@
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_export.h"
 
+namespace gpu {
+namespace gles2 {
+class GLES2Decoder;
+}
+}
 namespace gfx {
 
 class GLContext;
+class GLSurface;
 
 void InitializeGLBindingsGL();
 void InitializeGLExtensionBindingsGL(GLContext* context);
 void InitializeDebugGLBindingsGL();
 void ClearGLBindingsGL();
+void SetGLToRealGLApi();
+void SetGLApi(GLApi* api);
 
+// Implemenents the GL API by calling directly into the driver.
 class GL_EXPORT RealGLApi : public GLApi {
  public:
   RealGLApi();
+  virtual ~RealGLApi();
   void Initialize(DriverGL* driver);
 
   // Include the auto-generated part of this class. We split this because
@@ -32,6 +42,36 @@ class GL_EXPORT RealGLApi : public GLApi {
   DriverGL* driver_;
 };
 
+// Implementents the GL API using co-operative state restoring.
+// Assumes there is only one real GL context and that multiple virtual contexts
+// are implemented above it. Restores the needed state from the current context.
+class GL_EXPORT VirtualGLApi : public GLApi {
+ public:
+  VirtualGLApi();
+  virtual ~VirtualGLApi();
+  void Initialize(DriverGL* driver, GLContext* real_context);
+
+  // Include the auto-generated part of this class. We split this because
+  // it means we can easily edit the non-auto generated parts right here in
+  // this file instead of having to edit some template or the code generator.
+  #include "gl_bindings_api_autogen_gl.h"
+
+  // Sets the current virutal context.
+  bool MakeCurrent(GLContext* virtual_context, GLSurface* surface);
+
+ private:
+  DriverGL* driver_;
+
+  // The real context we're running on.
+  GLContext* real_context_;
+
+  // The current virtual context.
+  GLContext* current_context_;
+
+  // The current surface.
+  GLSurface* current_surface_;
+};
+
 }  // namespace gfx
 
 #endif  // UI_GL_GL_API_IMPLEMENTATION_H_
diff --git a/ui/gl/gl_glx_api_implementation.cc b/ui/gl/gl_glx_api_implementation.cc
index 9897119..8989756 100644
--- a/ui/gl/gl_glx_api_implementation.cc
+++ b/ui/gl/gl_glx_api_implementation.cc
@@ -43,6 +43,9 @@ GLXApi::~GLXApi() {
 RealGLXApi::RealGLXApi() {
 }
 
+RealGLXApi::~RealGLXApi() {
+}
+
 void RealGLXApi::Initialize(DriverGLX* driver) {
   driver_ = driver;
 }
diff --git a/ui/gl/gl_glx_api_implementation.h b/ui/gl/gl_glx_api_implementation.h
index 0be7224..396deeb 100644
--- a/ui/gl/gl_glx_api_implementation.h
+++ b/ui/gl/gl_glx_api_implementation.h
@@ -21,6 +21,7 @@ void ClearGLBindingsGLX();
 class GL_EXPORT RealGLXApi : public GLXApi {
  public:
   RealGLXApi();
+  virtual ~RealGLXApi();
   void Initialize(DriverGLX* driver);
 
   // Include the auto-generated part of this class. We split this because
diff --git a/ui/gl/gl_osmesa_api_implementation.cc b/ui/gl/gl_osmesa_api_implementation.cc
index 458a9e5..37cc57e 100644
--- a/ui/gl/gl_osmesa_api_implementation.cc
+++ b/ui/gl/gl_osmesa_api_implementation.cc
@@ -43,6 +43,9 @@ OSMESAApi::~OSMESAApi() {
 RealOSMESAApi::RealOSMESAApi() {
 }
 
+RealOSMESAApi::~RealOSMESAApi() {
+}
+
 void RealOSMESAApi::Initialize(DriverOSMESA* driver) {
   driver_ = driver;
 }
diff --git a/ui/gl/gl_osmesa_api_implementation.h b/ui/gl/gl_osmesa_api_implementation.h
index 95271f4..4101c74 100644
--- a/ui/gl/gl_osmesa_api_implementation.h
+++ b/ui/gl/gl_osmesa_api_implementation.h
@@ -21,6 +21,7 @@ void ClearGLBindingsOSMESA();
 class GL_EXPORT RealOSMESAApi : public OSMESAApi {
  public:
   RealOSMESAApi();
+  virtual ~RealOSMESAApi();
   void Initialize(DriverOSMESA* driver);
 
   // Include the auto-generated part of this class. We split this because
diff --git a/ui/gl/gl_state_restorer.cc b/ui/gl/gl_state_restorer.cc
new file mode 100644
index 0000000..8bf6f81
--- /dev/null
+++ b/ui/gl/gl_state_restorer.cc
@@ -0,0 +1,16 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gl/gl_state_restorer.h"
+
+namespace gfx {
+
+GLStateRestorer::GLStateRestorer() {
+}
+
+GLStateRestorer::~GLStateRestorer() {
+}
+
+}  // namespace gfx
+
diff --git a/ui/gl/gl_state_restorer.h b/ui/gl/gl_state_restorer.h
new file mode 100644
index 0000000..8366a7a
--- /dev/null
+++ b/ui/gl/gl_state_restorer.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2012 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.
+
+#ifndef UI_GL_GL_STATE_RESTORER_H_
+#define UI_GL_GL_STATE_RESTORER_H_
+
+#include "base/basictypes.h"
+#include "ui/gl/gl_export.h"
+
+namespace gfx {
+
+// An interface for Restoring GL State.
+// This will expand over time to provide an more optimizable implementation.
+class GL_EXPORT GLStateRestorer {
+ public:
+  GLStateRestorer();
+  virtual ~GLStateRestorer();
+
+  virtual void RestoreState() = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(GLStateRestorer);
+};
+
+}  // namespace gfx
+
+#endif  // UI_GL_GL_STATE_RESTORER_H_
diff --git a/ui/gl/gl_wgl_api_implementation.cc b/ui/gl/gl_wgl_api_implementation.cc
index 332698a..bbe1ecb 100644
--- a/ui/gl/gl_wgl_api_implementation.cc
+++ b/ui/gl/gl_wgl_api_implementation.cc
@@ -43,6 +43,9 @@ WGLApi::~WGLApi() {
 RealWGLApi::RealWGLApi() {
 }
 
+RealWGLApi::~RealWGLApi() {
+}
+
 void RealWGLApi::Initialize(DriverWGL* driver) {
   driver_ = driver;
 }
diff --git a/ui/gl/gl_wgl_api_implementation.h b/ui/gl/gl_wgl_api_implementation.h
index 35afd0a..2b7a09a 100644
--- a/ui/gl/gl_wgl_api_implementation.h
+++ b/ui/gl/gl_wgl_api_implementation.h
@@ -21,6 +21,7 @@ void ClearGLBindingsWGL();
 class GL_EXPORT RealWGLApi : public WGLApi {
  public:
   RealWGLApi();
+  virtual ~RealWGLApi();
   void Initialize(DriverWGL* driver);
 
   // Include the auto-generated part of this class. We split this because