BASELINE: Update Chromium to 58.0.3029.54

Change-Id: I67f57065a7afdc8e4614adb5c0230281428df4d1
Reviewed-by: Peter Varga <pvarga@inf.u-szeged.hu>

75 files changed, 6840 insertions, 10003 deletions

diff --git a/chromium/ui/gl/BUILD.gn b/chromium/ui/gl/BUILD.gn
index 360551d7654..79871957c16 100644
--- a/chromium/ui/gl/BUILD.gn
+++ b/chromium/ui/gl/BUILD.gn
@@ -65,8 +65,6 @@ component("gl") {
     "gl_context_osmesa.h",
     "gl_context_stub.cc",
     "gl_context_stub.h",
-    "gl_context_stub_with_extensions.cc",
-    "gl_context_stub_with_extensions.h",
     "gl_enums.cc",
     "gl_enums.h",
     "gl_enums_implementation_autogen.h",
@@ -122,8 +120,6 @@ component("gl") {
     "gpu_switching_manager.h",
     "gpu_timing.cc",
     "gpu_timing.h",
-    "scoped_api.cc",
-    "scoped_api.h",
     "scoped_binders.cc",
     "scoped_binders.h",
     "scoped_make_current.cc",
@@ -328,7 +324,9 @@ static_library("test_support") {
     "//ui/gl/init",
   ]
   deps = [
+    "//base/test:test_support",
     "//testing/gtest",
+    "//ui/base",
   ]
 
   if (use_x11) {
diff --git a/chromium/ui/gl/DEPS b/chromium/ui/gl/DEPS
index d2f429d9a3b..4f149287312 100644
--- a/chromium/ui/gl/DEPS
+++ b/chromium/ui/gl/DEPS
@@ -14,7 +14,7 @@ specific_include_rules = {
     "+third_party/mesa/src/include/GL/osmesa.h",
   ],
 # Allow us to include ANGLE's base platform implementation.
-  "angle_platform_impl.h": [
+  "angle_platform_impl.cc": [
     "+third_party/angle/include/platform/Platform.h",
   ],
   "gl_angle_util_win.cc": [
diff --git a/chromium/ui/gl/OWNERS b/chromium/ui/gl/OWNERS
index 476d77949e1..ff0f6be0e38 100644
--- a/chromium/ui/gl/OWNERS
+++ b/chromium/ui/gl/OWNERS
@@ -5,3 +5,5 @@ per-file *gl_image*=reveman@chromium.org
 per-file *_ozone*=alexst@chromium.org
 per-file *_ozone*=dnicoara@chromium.org
 per-file *_ozone*=spang@chromium.org
+
+# COMPONENT: Internals>GPU
diff --git a/chromium/ui/gl/angle_platform_impl.cc b/chromium/ui/gl/angle_platform_impl.cc
index 6a74fc29d04..1363fb97b4e 100644
--- a/chromium/ui/gl/angle_platform_impl.cc
+++ b/chromium/ui/gl/angle_platform_impl.cc
@@ -7,37 +7,42 @@
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
+#include "third_party/angle/include/platform/Platform.h"
+#include "ui/gl/gl_bindings.h"
 
 namespace gl {
 
-ANGLEPlatformImpl::ANGLEPlatformImpl() {
-}
+namespace {
 
-ANGLEPlatformImpl::~ANGLEPlatformImpl() {
-}
+angle::ResetDisplayPlatformFunc g_angle_reset_platform = nullptr;
 
-double ANGLEPlatformImpl::currentTime() {
+double ANGLEPlatformImpl_currentTime(angle::PlatformMethods* platform) {
   return base::Time::Now().ToDoubleT();
 }
 
-double ANGLEPlatformImpl::monotonicallyIncreasingTime() {
+double ANGLEPlatformImpl_monotonicallyIncreasingTime(
+    angle::PlatformMethods* platform) {
   return (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
 }
 
-const unsigned char* ANGLEPlatformImpl::getTraceCategoryEnabledFlag(
+const unsigned char* ANGLEPlatformImpl_getTraceCategoryEnabledFlag(
+    angle::PlatformMethods* platform,
     const char* category_group) {
   return TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_group);
 }
 
-void ANGLEPlatformImpl::logError(const char* errorMessage) {
+void ANGLEPlatformImpl_logError(angle::PlatformMethods* platform,
+                                const char* errorMessage) {
   LOG(ERROR) << errorMessage;
 }
 
-void ANGLEPlatformImpl::logWarning(const char* warningMessage) {
+void ANGLEPlatformImpl_logWarning(angle::PlatformMethods* platform,
+                                  const char* warningMessage) {
   LOG(WARNING) << warningMessage;
 }
 
-angle::Platform::TraceEventHandle ANGLEPlatformImpl::addTraceEvent(
+angle::TraceEventHandle ANGLEPlatformImpl_addTraceEvent(
+    angle::PlatformMethods* platform,
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
@@ -56,26 +61,28 @@ angle::Platform::TraceEventHandle ANGLEPlatformImpl::addTraceEvent(
           trace_event_internal::kGlobalScope, id, trace_event_internal::kNoId,
           base::PlatformThread::CurrentId(), timestamp_tt, num_args, arg_names,
           arg_types, arg_values, nullptr, flags);
-  angle::Platform::TraceEventHandle result;
+  angle::TraceEventHandle result;
   memcpy(&result, &handle, sizeof(result));
   return result;
 }
 
-void ANGLEPlatformImpl::updateTraceEventDuration(
+void ANGLEPlatformImpl_updateTraceEventDuration(
+    angle::PlatformMethods* platform,
     const unsigned char* category_group_enabled,
     const char* name,
-    TraceEventHandle handle) {
+    angle::TraceEventHandle handle) {
   base::trace_event::TraceEventHandle trace_event_handle;
   memcpy(&trace_event_handle, &handle, sizeof(handle));
   TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled, name,
                                               trace_event_handle);
 }
 
-void ANGLEPlatformImpl::histogramCustomCounts(const char* name,
-                                              int sample,
-                                              int min,
-                                              int max,
-                                              int bucket_count) {
+void ANGLEPlatformImpl_histogramCustomCounts(angle::PlatformMethods* platform,
+                                             const char* name,
+                                             int sample,
+                                             int min,
+                                             int max,
+                                             int bucket_count) {
   // Copied from histogram macro, but without the static variable caching
   // the histogram because name is dynamic.
   base::HistogramBase* counter = base::Histogram::FactoryGet(
@@ -85,9 +92,10 @@ void ANGLEPlatformImpl::histogramCustomCounts(const char* name,
   counter->Add(sample);
 }
 
-void ANGLEPlatformImpl::histogramEnumeration(const char* name,
-                                             int sample,
-                                             int boundary_value) {
+void ANGLEPlatformImpl_histogramEnumeration(angle::PlatformMethods* platform,
+                                            const char* name,
+                                            int sample,
+                                            int boundary_value) {
   // Copied from histogram macro, but without the static variable caching
   // the histogram because name is dynamic.
   base::HistogramBase* counter = base::LinearHistogram::FactoryGet(
@@ -97,14 +105,63 @@ void ANGLEPlatformImpl::histogramEnumeration(const char* name,
   counter->Add(sample);
 }
 
-void ANGLEPlatformImpl::histogramSparse(const char* name, int sample) {
+void ANGLEPlatformImpl_histogramSparse(angle::PlatformMethods* platform,
+                                       const char* name,
+                                       int sample) {
   // For sparse histograms, we can use the macro, as it does not incorporate a
   // static.
   UMA_HISTOGRAM_SPARSE_SLOWLY(name, sample);
 }
 
-void ANGLEPlatformImpl::histogramBoolean(const char* name, bool sample) {
-  histogramEnumeration(name, sample ? 1 : 0, 2);
+void ANGLEPlatformImpl_histogramBoolean(angle::PlatformMethods* platform,
+                                        const char* name,
+                                        bool sample) {
+  ANGLEPlatformImpl_histogramEnumeration(platform, name, sample ? 1 : 0, 2);
+}
+
+}  // anonymous namespace
+
+bool InitializeANGLEPlatform(EGLDisplay display) {
+  angle::GetDisplayPlatformFunc angle_get_platform =
+      reinterpret_cast<angle::GetDisplayPlatformFunc>(
+          eglGetProcAddress("ANGLEGetDisplayPlatform"));
+  if (!angle_get_platform)
+    return false;
+
+  // Save the pointer to the destroy function here to avoid crash.
+  g_angle_reset_platform = reinterpret_cast<angle::ResetDisplayPlatformFunc>(
+      eglGetProcAddress("ANGLEResetDisplayPlatform"));
+
+  angle::PlatformMethods* platformMethods = nullptr;
+  if (!angle_get_platform(static_cast<angle::EGLDisplayType>(display),
+                          angle::g_PlatformMethodNames,
+                          angle::g_NumPlatformMethods, nullptr,
+                          &platformMethods))
+    return false;
+  platformMethods->currentTime = ANGLEPlatformImpl_currentTime;
+  platformMethods->addTraceEvent = ANGLEPlatformImpl_addTraceEvent;
+  platformMethods->currentTime = ANGLEPlatformImpl_currentTime;
+  platformMethods->getTraceCategoryEnabledFlag =
+      ANGLEPlatformImpl_getTraceCategoryEnabledFlag;
+  platformMethods->histogramBoolean = ANGLEPlatformImpl_histogramBoolean;
+  platformMethods->histogramCustomCounts =
+      ANGLEPlatformImpl_histogramCustomCounts;
+  platformMethods->histogramEnumeration =
+      ANGLEPlatformImpl_histogramEnumeration;
+  platformMethods->histogramSparse = ANGLEPlatformImpl_histogramSparse;
+  platformMethods->logError = ANGLEPlatformImpl_logError;
+  platformMethods->logWarning = ANGLEPlatformImpl_logWarning;
+  platformMethods->monotonicallyIncreasingTime =
+      ANGLEPlatformImpl_monotonicallyIncreasingTime;
+  platformMethods->updateTraceEventDuration =
+      ANGLEPlatformImpl_updateTraceEventDuration;
+  return true;
+}
+
+void ResetANGLEPlatform(EGLDisplay display) {
+  if (!g_angle_reset_platform)
+    return;
+  g_angle_reset_platform(static_cast<angle::EGLDisplayType>(display));
 }
 
 }  // namespace gl
diff --git a/chromium/ui/gl/angle_platform_impl.h b/chromium/ui/gl/angle_platform_impl.h
index 99c59a6c0bb..38c93ab678a 100644
--- a/chromium/ui/gl/angle_platform_impl.h
+++ b/chromium/ui/gl/angle_platform_impl.h
@@ -8,53 +8,12 @@
 // Implements the ANGLE platform interface, for functionality like
 // histograms and trace profiling.
 
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "third_party/angle/include/platform/Platform.h"
-#include "ui/gl/gl_export.h"
+#include "ui/gl/gl_context_egl.h"
 
 namespace gl {
 
-// Derives the base ANGLE platform and provides implementations
-class GL_EXPORT ANGLEPlatformImpl : NON_EXPORTED_BASE(public angle::Platform) {
- public:
-  ANGLEPlatformImpl();
-  ~ANGLEPlatformImpl() override;
-
-  // angle::Platform:
-  double currentTime() override;
-  double monotonicallyIncreasingTime() override;
-  void logError(const char* errorMessage) override;
-  void logWarning(const char* warningMessage) override;
-  const unsigned char* getTraceCategoryEnabledFlag(
-      const char* category_group) override;
-  TraceEventHandle addTraceEvent(char phase,
-                                 const unsigned char* category_group_enabled,
-                                 const char* name,
-                                 unsigned long long id,
-                                 double timestamp,
-                                 int num_args,
-                                 const char** arg_names,
-                                 const unsigned char* arg_types,
-                                 const unsigned long long* arg_values,
-                                 unsigned char flags) override;
-  void updateTraceEventDuration(const unsigned char* category_group_enabled,
-                                const char* name,
-                                TraceEventHandle handle) override;
-  void histogramCustomCounts(const char* name,
-                             int sample,
-                             int min,
-                             int max,
-                             int bucket_count) override;
-  void histogramEnumeration(const char* name,
-                            int sample,
-                            int boundary_value) override;
-  void histogramSparse(const char* name, int sample) override;
-  void histogramBoolean(const char* name, bool sample) override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ANGLEPlatformImpl);
-};
+bool InitializeANGLEPlatform(EGLDisplay display);
+void ResetANGLEPlatform(EGLDisplay display);
 
 }  // namespace gl
 
diff --git a/chromium/ui/gl/generate_bindings.py b/chromium/ui/gl/generate_bindings.py
index d06481ab5a7..5ef8b9f2ef0 100755
--- a/chromium/ui/gl/generate_bindings.py
+++ b/chromium/ui/gl/generate_bindings.py
@@ -2556,8 +2556,8 @@ namespace gl {
 """ % includes_string)
 
   file.write('\n')
-  file.write('static bool g_debugBindingsInitialized;\n')
-  file.write('Driver%s g_driver_%s;\n' % (set_name.upper(), set_name.lower()))
+  if set_name != 'gl':
+    file.write('Driver%s g_driver_%s;\n' % (set_name.upper(), set_name.lower()))
   file.write('\n')
 
   # Write stub functions that take the place of some functions before a context
@@ -2650,11 +2650,8 @@ namespace gl {
   if set_name == 'gl':
     file.write("""\
 void DriverGL::InitializeDynamicBindings(
-    GLContext* context) {
-  DCHECK(context && context->IsCurrent(NULL));
-  const GLVersionInfo* ver = context->GetVersionInfo();
-  ALLOW_UNUSED_LOCAL(ver);
-  std::string extensions = context->GetExtensions() + " ";
+    const GLVersionInfo* ver, const std::string& context_extensions) {
+  std::string extensions = context_extensions + " ";
   ALLOW_UNUSED_LOCAL(extensions);
 
 """)
@@ -2685,7 +2682,6 @@ void Driver%s::InitializeExtensionBindings() {
     for func in extension_funcs:
       if not 'static_binding' in func:
         file.write('\n')
-        file.write('  debug_fn.%sFn = 0;\n' % func['known_as'])
         WriteConditionalFuncBinding(file, func)
 
   OutputExtensionBindings(
@@ -2708,22 +2704,67 @@ void DriverEGL::InitializeExtensionBindings() {
     'extensions',
     sorted(used_extensions),
     [ f for f in functions if not IsClientExtensionFunc(f) ])
-
-  # Some new function pointers have been added, so update them in debug bindings
-  file.write('\n')
-  file.write('  if (g_debugBindingsInitialized)\n')
-  file.write('    InitializeDebugBindings();\n')
   file.write('}\n')
+
+  # Write function to clear all function pointers.
   file.write('\n')
+  file.write("""void Driver%s::ClearBindings() {
+  memset(this, 0, sizeof(*this));
+}
+""" % set_name.upper())
+
+  def MakeArgNames(arguments):
+    argument_names = re.sub(
+        r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', arguments)
+    argument_names = re.sub(
+        r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', argument_names)
+    if argument_names == 'void' or argument_names == '':
+      argument_names = ''
+    return argument_names
+
+  # Write GLApiBase functions
+  for func in functions:
+    function_name = func['known_as']
+    return_type = func['return_type']
+    arguments = func['arguments']
+    file.write('\n')
+    file.write('%s %sApiBase::%sFn(%s) {\n' %
+        (return_type, set_name.upper(), function_name, arguments))
+    argument_names = MakeArgNames(arguments)
+    if return_type == 'void':
+      file.write('  driver_->fn.%sFn(%s);\n' %
+          (function_name, argument_names))
+    else:
+      file.write('  return driver_->fn.%sFn(%s);\n' %
+          (function_name, argument_names))
+    file.write('}\n')
+
+  # Write TraceGLApi functions
+  for func in functions:
+    function_name = func['known_as']
+    return_type = func['return_type']
+    arguments = func['arguments']
+    file.write('\n')
+    file.write('%s Trace%sApi::%sFn(%s) {\n' %
+        (return_type, set_name.upper(), function_name, arguments))
+    argument_names = MakeArgNames(arguments)
+    file.write('  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::%s")\n' %
+               function_name)
+    if return_type == 'void':
+      file.write('  %s_api_->%sFn(%s);\n' %
+          (set_name.lower(), function_name, argument_names))
+    else:
+      file.write('  return %s_api_->%sFn(%s);\n' %
+          (set_name.lower(), function_name, argument_names))
+    file.write('}\n')
 
-  # Write logging wrappers for each function.
-  file.write('extern "C" {\n')
+  # Write DebugGLApi functions
   for func in functions:
     return_type = func['return_type']
     arguments = func['arguments']
     file.write('\n')
-    file.write('static %s GL_BINDING_CALL Debug_%s(%s) {\n' %
-        (return_type, func['known_as'], arguments))
+    file.write('%s Debug%sApi::%sFn(%s) {\n' %
+        (return_type, set_name.upper(), func['known_as'], arguments))
     argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', arguments)
     argument_names = re.sub(
@@ -2764,23 +2805,20 @@ void DriverEGL::InitializeExtensionBindings() {
     if return_type == 'void':
       file.write('  GL_SERVICE_LOG("%s" << "(" %s << ")");\n' %
           (function_name, log_argument_names))
-      file.write('  DCHECK(g_driver_%s.debug_fn.%sFn != nullptr);\n' %
-          (set_name.lower(), function_name))
-      file.write('  g_driver_%s.debug_fn.%sFn(%s);\n' %
+      file.write('  %s_api_->%sFn(%s);\n' %
           (set_name.lower(), function_name, argument_names))
       if 'logging_code' in func:
         file.write("%s\n" % func['logging_code'])
       if options.generate_dchecks and set_name == 'gl':
         file.write('  {\n')
-        file.write('    GLenum error = g_driver_gl.debug_fn.glGetErrorFn();\n')
+        file.write('    GLenum error = %s_api_->glGetErrorFn();\n'
+            % set_name.lower())
         file.write('    DCHECK(error == 0);\n')
         file.write('  }\n')
     else:
       file.write('  GL_SERVICE_LOG("%s" << "(" %s << ")");\n' %
           (function_name, log_argument_names))
-      file.write('  DCHECK(g_driver_%s.debug_fn.%sFn != nullptr);\n' %
-          (set_name.lower(), function_name))
-      file.write('  %s result = g_driver_%s.debug_fn.%sFn(%s);\n' %
+      file.write('  %s result = %s_api_->%sFn(%s);\n' %
           (return_type, set_name.lower(), function_name, argument_names))
       if 'logging_code' in func:
         file.write("%s\n" % func['logging_code'])
@@ -2788,77 +2826,12 @@ void DriverEGL::InitializeExtensionBindings() {
         file.write('  GL_SERVICE_LOG("GL_RESULT: " << result);\n')
       if options.generate_dchecks and set_name == 'gl':
         file.write('  {\n')
-        file.write('    GLenum _error = g_driver_gl.debug_fn.glGetErrorFn();\n')
+        file.write('    GLenum _error = %s_api_->glGetErrorFn();\n' %
+            set_name.lower())
         file.write('    DCHECK(_error == 0);\n')
         file.write('  }\n')
       file.write('  return result;\n')
     file.write('}\n')
-  file.write('}  // extern "C"\n')
-
-  # Write function to initialize the debug function pointers.
-  file.write('\n')
-  file.write('void Driver%s::InitializeDebugBindings() {\n' %
-             set_name.upper())
-  for func in functions:
-    first_name = func['known_as']
-    file.write('  if (!debug_fn.%sFn) {\n' % first_name)
-    file.write('    debug_fn.%sFn = fn.%sFn;\n' % (first_name, first_name))
-    file.write('    fn.%sFn = Debug_%s;\n' % (first_name, first_name))
-    file.write('  }\n')
-  file.write('  g_debugBindingsInitialized = true;\n')
-  file.write('}\n')
-
-  # Write function to clear all function pointers.
-  file.write('\n')
-  file.write("""void Driver%s::ClearBindings() {
-  memset(this, 0, sizeof(*this));
-}
-""" % set_name.upper())
-
-  def MakeArgNames(arguments):
-    argument_names = re.sub(
-        r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', arguments)
-    argument_names = re.sub(
-        r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', argument_names)
-    if argument_names == 'void' or argument_names == '':
-      argument_names = ''
-    return argument_names
-
-  # Write GLApiBase functions
-  for func in functions:
-    function_name = func['known_as']
-    return_type = func['return_type']
-    arguments = func['arguments']
-    file.write('\n')
-    file.write('%s %sApiBase::%sFn(%s) {\n' %
-        (return_type, set_name.upper(), function_name, arguments))
-    argument_names = MakeArgNames(arguments)
-    if return_type == 'void':
-      file.write('  driver_->fn.%sFn(%s);\n' %
-          (function_name, argument_names))
-    else:
-      file.write('  return driver_->fn.%sFn(%s);\n' %
-          (function_name, argument_names))
-    file.write('}\n')
-
-  # Write TraceGLApi functions
-  for func in functions:
-    function_name = func['known_as']
-    return_type = func['return_type']
-    arguments = func['arguments']
-    file.write('\n')
-    file.write('%s Trace%sApi::%sFn(%s) {\n' %
-        (return_type, set_name.upper(), function_name, arguments))
-    argument_names = MakeArgNames(arguments)
-    file.write('  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::%s")\n' %
-               function_name)
-    if return_type == 'void':
-      file.write('  %s_api_->%sFn(%s);\n' %
-          (set_name.lower(), function_name, argument_names))
-    else:
-      file.write('  return %s_api_->%sFn(%s);\n' %
-          (set_name.lower(), function_name, argument_names))
-    file.write('}\n')
 
   # Write NoContextGLApi functions
   if set_name.upper() == "GL":
diff --git a/chromium/ui/gl/gl_angle_util_win.cc b/chromium/ui/gl/gl_angle_util_win.cc
index 4a2b37c4252..6bd8faab069 100644
--- a/chromium/ui/gl/gl_angle_util_win.cc
+++ b/chromium/ui/gl/gl_angle_util_win.cc
@@ -82,4 +82,54 @@ base::win::ScopedComPtr<IDirect3DDevice9> QueryD3D9DeviceObjectFromANGLE() {
   return d3d9_device;
 }
 
+base::win::ScopedComPtr<IDCompositionDevice2> QueryDirectCompositionDevice(
+    base::win::ScopedComPtr<ID3D11Device> d3d11_device) {
+  // Each D3D11 device will have a DirectComposition device stored in its
+  // private data under this GUID.
+  // {CF81D85A-8D30-4769-8509-B9D73898D870}
+  static const GUID kDirectCompositionGUID = {
+      0xcf81d85a,
+      0x8d30,
+      0x4769,
+      {0x85, 0x9, 0xb9, 0xd7, 0x38, 0x98, 0xd8, 0x70}};
+
+  base::win::ScopedComPtr<IDCompositionDevice2> dcomp_device;
+  if (!d3d11_device)
+    return dcomp_device;
+
+  UINT data_size = sizeof(dcomp_device.get());
+  HRESULT hr = d3d11_device->GetPrivateData(kDirectCompositionGUID, &data_size,
+                                            dcomp_device.ReceiveVoid());
+  if (SUCCEEDED(hr) && dcomp_device)
+    return dcomp_device;
+
+  // Allocate a new DirectComposition device if none currently exists.
+  HMODULE dcomp_module = ::GetModuleHandle(L"dcomp.dll");
+  if (!dcomp_module)
+    return dcomp_device;
+
+  using PFN_DCOMPOSITION_CREATE_DEVICE2 = HRESULT(WINAPI*)(
+      IUnknown * renderingDevice, REFIID iid, void** dcompositionDevice);
+  PFN_DCOMPOSITION_CREATE_DEVICE2 create_device_function =
+      reinterpret_cast<PFN_DCOMPOSITION_CREATE_DEVICE2>(
+          ::GetProcAddress(dcomp_module, "DCompositionCreateDevice2"));
+  if (!create_device_function)
+    return dcomp_device;
+
+  base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
+  d3d11_device.QueryInterface(dxgi_device.Receive());
+  base::win::ScopedComPtr<IDCompositionDesktopDevice> desktop_device;
+  hr = create_device_function(dxgi_device.get(),
+                              IID_PPV_ARGS(desktop_device.Receive()));
+  if (FAILED(hr))
+    return dcomp_device;
+
+  hr = desktop_device.QueryInterface(dcomp_device.Receive());
+  CHECK(SUCCEEDED(hr));
+  d3d11_device->SetPrivateDataInterface(kDirectCompositionGUID,
+                                        dcomp_device.get());
+
+  return dcomp_device;
+}
+
 }  // namespace gl
diff --git a/chromium/ui/gl/gl_angle_util_win.h b/chromium/ui/gl/gl_angle_util_win.h
index 6f08f9132a4..b0a4a802181 100644
--- a/chromium/ui/gl/gl_angle_util_win.h
+++ b/chromium/ui/gl/gl_angle_util_win.h
@@ -7,6 +7,7 @@
 
 #include <d3d11.h>
 #include <d3d9.h>
+#include <dcomp.h>
 
 #include "base/win/scoped_comptr.h"
 #include "ui/gl/gl_export.h"
@@ -18,6 +19,12 @@ QueryD3D11DeviceObjectFromANGLE();
 GL_EXPORT base::win::ScopedComPtr<IDirect3DDevice9>
 QueryD3D9DeviceObjectFromANGLE();
 
+// Query the DirectComposition device associated with a D3D11 device. May
+// create a new one if none exists.
+GL_EXPORT base::win::ScopedComPtr<IDCompositionDevice2>
+QueryDirectCompositionDevice(
+    base::win::ScopedComPtr<ID3D11Device> d3d11_device);
+
 }  // namespace gl
 
 #endif  // UI_GL_GL_ANGLE_UTIL_WIN_H_
diff --git a/chromium/ui/gl/gl_api_unittest.cc b/chromium/ui/gl/gl_api_unittest.cc
index 6f274b46734..f0185c670e1 100644
--- a/chromium/ui/gl/gl_api_unittest.cc
+++ b/chromium/ui/gl/gl_api_unittest.cc
@@ -13,29 +13,11 @@
 #include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
+#include "ui/gl/gl_version_info.h"
 #include "ui/gl/gpu_timing.h"
 
 namespace gl {
 
-class GLContextFake : public GLContext {
- public:
-  bool Initialize(GLSurface* compatible_surface,
-                  const GLContextAttribs& attribs) override {
-    return true;
-  }
-  bool MakeCurrent(GLSurface* surface) override { return true; }
-  void ReleaseCurrent(GLSurface* surface) override {}
-  bool IsCurrent(GLSurface* surface) override { return true; }
-  void* GetHandle() override { return NULL; }
-  scoped_refptr<GPUTimingClient> CreateGPUTimingClient() override {
-    return NULL;
-  }
-  void OnSetSwapInterval(int interval) override {}
-  GLContextFake() : GLContext(NULL) {}
- protected:
-  ~GLContextFake() override {}
-};
-
 class GLApiTest : public testing::Test {
  public:
   void SetUp() override {
@@ -44,9 +26,6 @@ class GLApiTest : public testing::Test {
     num_fake_extension_strings_ = 0;
     fake_extension_strings_ = nullptr;
 
-    DCHECK(!g_current_gl_context_tls);
-    g_current_gl_context_tls = new base::ThreadLocalPointer<GLApi>;
-
     SetGLGetProcAddressProc(
         static_cast<GLGetProcAddressProc>(&FakeGLGetProcAddress));
   }
@@ -58,8 +37,7 @@ class GLApiTest : public testing::Test {
 
   void TearDown() override {
     api_.reset(nullptr);
-    delete g_current_gl_context_tls;
-    g_current_gl_context_tls = nullptr;
+    driver_.reset(nullptr);
 
     SetGLImplementation(kGLImplementationNone);
     fake_extension_string_ = "";
@@ -69,21 +47,23 @@ class GLApiTest : public testing::Test {
   }
 
   void InitializeAPI(base::CommandLine* command_line) {
-    api_.reset(new RealGLApi());
-    g_current_gl_context_tls->Set(api_.get());
-
-    g_driver_gl.ClearBindings();
-    g_driver_gl.fn.glGetStringFn = &FakeGetString;
-    g_driver_gl.fn.glGetStringiFn = &FakeGetStringi;
-    g_driver_gl.fn.glGetIntegervFn = &FakeGetIntegervFn;
+    driver_.reset(new DriverGL());
+    driver_->fn.glGetStringFn = &FakeGetString;
+    driver_->fn.glGetStringiFn = &FakeGetStringi;
+    driver_->fn.glGetIntegervFn = &FakeGetIntegervFn;
 
-    fake_context_ = new GLContextFake();
+    api_.reset(new RealGLApi());
     if (command_line)
-      api_->InitializeWithCommandLine(&g_driver_gl, command_line);
+      api_->InitializeWithCommandLine(driver_.get(), command_line);
     else
-      api_->Initialize(&g_driver_gl);
+      api_->Initialize(driver_.get());
+
     api_->InitializeFilteredExtensions();
-    g_driver_gl.InitializeCustomDynamicBindings(fake_context_.get());
+    std::unique_ptr<GLVersionInfo> version =
+        GetVersionInfoFromContext(api_.get());
+    driver_->InitializeDynamicBindings(
+        version.get(), GetGLExtensionsFromCurrentContext(api_.get()));
+    api_->set_version(std::move(version));
   }
 
   void SetFakeExtensionString(const char* fake_string) {
@@ -138,7 +118,6 @@ class GLApiTest : public testing::Test {
   static uint32_t num_fake_extension_strings_;
   static const char** fake_extension_strings_;
 
-  scoped_refptr<GLContext> fake_context_;
   std::unique_ptr<DriverGL> driver_;
   std::unique_ptr<RealGLApi> api_;
 };
@@ -176,14 +155,14 @@ TEST_F(GLApiTest, DisabledExtensionBitTest) {
   SetFakeExtensionStrings(kFakeExtensions, arraysize(kFakeExtensions));
   InitializeAPI(nullptr);
 
-  EXPECT_TRUE(g_driver_gl.ext.b_GL_ARB_timer_query);
+  EXPECT_TRUE(driver_->ext.b_GL_ARB_timer_query);
 
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kDisableGLExtensions,
                                  kFakeDisabledExtensions);
   InitializeAPI(&command_line);
 
-  EXPECT_FALSE(g_driver_gl.ext.b_GL_ARB_timer_query);
+  EXPECT_FALSE(driver_->ext.b_GL_ARB_timer_query);
 }
 
 TEST_F(GLApiTest, DisabledExtensionStringIndexTest) {
diff --git a/chromium/ui/gl/gl_bindings.h b/chromium/ui/gl/gl_bindings.h
index b1044f8f4fa..3592fd1457d 100644
--- a/chromium/ui/gl/gl_bindings.h
+++ b/chromium/ui/gl/gl_bindings.h
@@ -110,6 +110,9 @@
 // GL_ANGLE_instanced_arrays
 #define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE             0x88FE
 
+// GL_ANGLE_client_arrays
+#define GL_CLIENT_ARRAYS_ANGLE 0x93AA
+
 // GL_EXT_occlusion_query_boolean
 #define GL_ANY_SAMPLES_PASSED_EXT                        0x8C2F
 #define GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT           0x8D6A
@@ -117,6 +120,9 @@
 #define GL_QUERY_RESULT_EXT                              0x8866
 #define GL_QUERY_RESULT_AVAILABLE_EXT                    0x8867
 
+// GL_ARB_occlusion_query
+#define GL_SAMPLES_PASSED_ARB                            0x8914
+
 // GL_CHROMIUM_command_buffer_query
 #define GL_COMMANDS_ISSUED_CHROMIUM                      0x6004
 
@@ -132,9 +138,6 @@
 // GL_CHROMIUM_sync_query
 #define GL_COMMANDS_COMPLETED_CHROMIUM                   0x84F7
 
-// GL_CHROMIUM_gpu_memory_buffer_image
-#define GL_READ_WRITE_CHROMIUM                           0x78F2
-
 // GL_CHROMIUM_ycrcb_420_image
 #define GL_RGB_YCRCB_420_CHROMIUM                        0x78FA
 
@@ -394,34 +397,30 @@ typedef uint64_t EGLuint64CHROMIUM;
 
 namespace gl {
 
+struct GLVersionInfo;
+
 struct GL_EXPORT DriverGL {
   void InitializeStaticBindings();
-  void InitializeCustomDynamicBindings(GLContext* context);
-  void InitializeDebugBindings();
-  void InitializeNullDrawBindings();
-  // TODO(danakj): Remove this when all test suites are using null-draw.
-  bool HasInitializedNullDrawBindings();
-  bool SetNullDrawBindingsEnabled(bool enabled);
+  void InitializeDynamicBindings(const GLVersionInfo* ver,
+                                 const std::string& context_extensions);
   void ClearBindings();
 
   ProcsGL fn;
-  ProcsGL orig_fn;
-  ProcsGL debug_fn;
   ExtensionsGL ext;
-  bool null_draw_bindings_enabled;
+};
 
- private:
-  void InitializeDynamicBindings(GLContext* context);
+struct GL_EXPORT CurrentGL {
+  GLApi* Api = nullptr;
+  DriverGL* Driver = nullptr;
+  const GLVersionInfo* Version = nullptr;
 };
 
 struct GL_EXPORT DriverOSMESA {
   void InitializeStaticBindings();
   void InitializeExtensionBindings();
-  void InitializeDebugBindings();
   void ClearBindings();
 
   ProcsOSMESA fn;
-  ProcsOSMESA debug_fn;
   ExtensionsOSMESA ext;
 
  private:
@@ -432,11 +431,9 @@ struct GL_EXPORT DriverOSMESA {
 struct GL_EXPORT DriverWGL {
   void InitializeStaticBindings();
   void InitializeExtensionBindings();
-  void InitializeDebugBindings();
   void ClearBindings();
 
   ProcsWGL fn;
-  ProcsWGL debug_fn;
   ExtensionsWGL ext;
 
  private:
@@ -449,11 +446,9 @@ struct GL_EXPORT DriverEGL {
   void InitializeStaticBindings();
   void InitializeClientExtensionBindings();
   void InitializeExtensionBindings();
-  void InitializeDebugBindings();
   void ClearBindings();
 
   ProcsEGL fn;
-  ProcsEGL debug_fn;
   ExtensionsEGL ext;
 
   static std::string GetPlatformExtensions();
@@ -465,11 +460,9 @@ struct GL_EXPORT DriverEGL {
 struct GL_EXPORT DriverGLX {
   void InitializeStaticBindings();
   void InitializeExtensionBindings();
-  void InitializeDebugBindings();
   void ClearBindings();
 
   ProcsGLX fn;
-  ProcsGLX debug_fn;
   ExtensionsGLX ext;
 
  private:
@@ -478,11 +471,12 @@ struct GL_EXPORT DriverGLX {
 #endif
 
 // This #define is here to support autogenerated code.
-#define g_current_gl_context g_current_gl_context_tls->Get()
-GL_EXPORT extern base::ThreadLocalPointer<GLApi>* g_current_gl_context_tls;
+#define g_current_gl_context g_current_gl_context_tls->Get()->Api
+#define g_current_gl_driver g_current_gl_context_tls->Get()->Driver
+#define g_current_gl_version g_current_gl_context_tls->Get()->Version
+GL_EXPORT extern base::ThreadLocalPointer<CurrentGL>* g_current_gl_context_tls;
 
 GL_EXPORT extern OSMESAApi* g_current_osmesa_context;
-GL_EXPORT extern DriverGL g_driver_gl;
 GL_EXPORT extern DriverOSMESA g_driver_osmesa;
 
 #if defined(USE_EGL)
diff --git a/chromium/ui/gl/gl_bindings_autogen_egl.cc b/chromium/ui/gl/gl_bindings_autogen_egl.cc
index ed0a6cf5ab8..79cc51cc5ba 100644
--- a/chromium/ui/gl/gl_bindings_autogen_egl.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_egl.cc
@@ -20,7 +20,6 @@
 
 namespace gl {
 
-static bool g_debugBindingsInitialized;
 DriverEGL g_driver_egl;
 
 void DriverEGL::InitializeStaticBindings() {
@@ -131,7 +130,6 @@ void DriverEGL::InitializeClientExtensionBindings() {
   ext.b_EGL_EXT_platform_base =
       client_extensions.find("EGL_EXT_platform_base ") != std::string::npos;
 
-  debug_fn.eglGetPlatformDisplayEXTFn = 0;
   if (ext.b_EGL_EXT_platform_base) {
     fn.eglGetPlatformDisplayEXTFn =
         reinterpret_cast<eglGetPlatformDisplayEXTProc>(
@@ -186,1119 +184,111 @@ void DriverEGL::InitializeExtensionBindings() {
       extensions.find("GL_CHROMIUM_egl_khr_fence_sync_hack ") !=
       std::string::npos;
 
-  debug_fn.eglCreateImageKHRFn = 0;
   if (ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base ||
       ext.b_EGL_KHR_gl_texture_2D_image) {
     fn.eglCreateImageKHRFn = reinterpret_cast<eglCreateImageKHRProc>(
         GetGLProcAddress("eglCreateImageKHR"));
   }
 
-  debug_fn.eglCreateStreamKHRFn = 0;
   if (ext.b_EGL_KHR_stream) {
     fn.eglCreateStreamKHRFn = reinterpret_cast<eglCreateStreamKHRProc>(
         GetGLProcAddress("eglCreateStreamKHR"));
   }
 
-  debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn = 0;
   if (ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12) {
     fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
         reinterpret_cast<eglCreateStreamProducerD3DTextureNV12ANGLEProc>(
             GetGLProcAddress("eglCreateStreamProducerD3DTextureNV12ANGLE"));
   }
 
-  debug_fn.eglDestroyImageKHRFn = 0;
   if (ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base) {
     fn.eglDestroyImageKHRFn = reinterpret_cast<eglDestroyImageKHRProc>(
         GetGLProcAddress("eglDestroyImageKHR"));
   }
 
-  debug_fn.eglDestroyStreamKHRFn = 0;
   if (ext.b_EGL_KHR_stream) {
     fn.eglDestroyStreamKHRFn = reinterpret_cast<eglDestroyStreamKHRProc>(
         GetGLProcAddress("eglDestroyStreamKHR"));
   }
 
-  debug_fn.eglGetSyncValuesCHROMIUMFn = 0;
   if (ext.b_EGL_CHROMIUM_sync_control) {
     fn.eglGetSyncValuesCHROMIUMFn =
         reinterpret_cast<eglGetSyncValuesCHROMIUMProc>(
             GetGLProcAddress("eglGetSyncValuesCHROMIUM"));
   }
 
-  debug_fn.eglImageFlushExternalEXTFn = 0;
   if (ext.b_EGL_EXT_image_flush_external) {
     fn.eglImageFlushExternalEXTFn =
         reinterpret_cast<eglImageFlushExternalEXTProc>(
             GetGLProcAddress("eglImageFlushExternalEXT"));
   }
 
-  debug_fn.eglPostSubBufferNVFn = 0;
   if (ext.b_EGL_NV_post_sub_buffer) {
     fn.eglPostSubBufferNVFn = reinterpret_cast<eglPostSubBufferNVProc>(
         GetGLProcAddress("eglPostSubBufferNV"));
   }
 
-  debug_fn.eglQueryStreamKHRFn = 0;
   if (ext.b_EGL_KHR_stream) {
     fn.eglQueryStreamKHRFn = reinterpret_cast<eglQueryStreamKHRProc>(
         GetGLProcAddress("eglQueryStreamKHR"));
   }
 
-  debug_fn.eglQueryStreamu64KHRFn = 0;
   if (ext.b_EGL_KHR_stream) {
     fn.eglQueryStreamu64KHRFn = reinterpret_cast<eglQueryStreamu64KHRProc>(
         GetGLProcAddress("eglQueryStreamu64KHR"));
   }
 
-  debug_fn.eglQuerySurfacePointerANGLEFn = 0;
   if (ext.b_EGL_ANGLE_query_surface_pointer) {
     fn.eglQuerySurfacePointerANGLEFn =
         reinterpret_cast<eglQuerySurfacePointerANGLEProc>(
             GetGLProcAddress("eglQuerySurfacePointerANGLE"));
   }
 
-  debug_fn.eglStreamAttribKHRFn = 0;
   if (ext.b_EGL_KHR_stream) {
     fn.eglStreamAttribKHRFn = reinterpret_cast<eglStreamAttribKHRProc>(
         GetGLProcAddress("eglStreamAttribKHR"));
   }
 
-  debug_fn.eglStreamConsumerAcquireKHRFn = 0;
   if (ext.b_EGL_KHR_stream_consumer_gltexture) {
     fn.eglStreamConsumerAcquireKHRFn =
         reinterpret_cast<eglStreamConsumerAcquireKHRProc>(
             GetGLProcAddress("eglStreamConsumerAcquireKHR"));
   }
 
-  debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn = 0;
   if (ext.b_EGL_NV_stream_consumer_gltexture_yuv) {
     fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
         reinterpret_cast<eglStreamConsumerGLTextureExternalAttribsNVProc>(
             GetGLProcAddress("eglStreamConsumerGLTextureExternalAttribsNV"));
   }
 
-  debug_fn.eglStreamConsumerGLTextureExternalKHRFn = 0;
   if (ext.b_EGL_KHR_stream_consumer_gltexture) {
     fn.eglStreamConsumerGLTextureExternalKHRFn =
         reinterpret_cast<eglStreamConsumerGLTextureExternalKHRProc>(
             GetGLProcAddress("eglStreamConsumerGLTextureExternalKHR"));
   }
 
-  debug_fn.eglStreamConsumerReleaseKHRFn = 0;
   if (ext.b_EGL_KHR_stream_consumer_gltexture) {
     fn.eglStreamConsumerReleaseKHRFn =
         reinterpret_cast<eglStreamConsumerReleaseKHRProc>(
             GetGLProcAddress("eglStreamConsumerReleaseKHR"));
   }
 
-  debug_fn.eglStreamPostD3DTextureNV12ANGLEFn = 0;
   if (ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12) {
     fn.eglStreamPostD3DTextureNV12ANGLEFn =
         reinterpret_cast<eglStreamPostD3DTextureNV12ANGLEProc>(
             GetGLProcAddress("eglStreamPostD3DTextureNV12ANGLE"));
   }
 
-  debug_fn.eglSwapBuffersWithDamageKHRFn = 0;
   if (ext.b_EGL_KHR_swap_buffers_with_damage) {
     fn.eglSwapBuffersWithDamageKHRFn =
         reinterpret_cast<eglSwapBuffersWithDamageKHRProc>(
             GetGLProcAddress("eglSwapBuffersWithDamageKHR"));
   }
 
-  debug_fn.eglWaitSyncKHRFn = 0;
   if (ext.b_EGL_KHR_wait_sync) {
     fn.eglWaitSyncKHRFn = reinterpret_cast<eglWaitSyncKHRProc>(
         GetGLProcAddress("eglWaitSyncKHR"));
   }
-
-  if (g_debugBindingsInitialized)
-    InitializeDebugBindings();
-}
-
-extern "C" {
-
-static EGLBoolean GL_BINDING_CALL Debug_eglBindAPI(EGLenum api) {
-  GL_SERVICE_LOG("eglBindAPI"
-                 << "(" << api << ")");
-  DCHECK(g_driver_egl.debug_fn.eglBindAPIFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglBindAPIFn(api);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglBindTexImage(EGLDisplay dpy,
-                                                        EGLSurface surface,
-                                                        EGLint buffer) {
-  GL_SERVICE_LOG("eglBindTexImage"
-                 << "(" << dpy << ", " << surface << ", " << buffer << ")");
-  DCHECK(g_driver_egl.debug_fn.eglBindTexImageFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglBindTexImageFn(dpy, surface, buffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglChooseConfig(EGLDisplay dpy,
-                      const EGLint* attrib_list,
-                      EGLConfig* configs,
-                      EGLint config_size,
-                      EGLint* num_config) {
-  GL_SERVICE_LOG("eglChooseConfig"
-                 << "(" << dpy << ", " << static_cast<const void*>(attrib_list)
-                 << ", " << static_cast<const void*>(configs) << ", "
-                 << config_size << ", " << static_cast<const void*>(num_config)
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglChooseConfigFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglChooseConfigFn(
-      dpy, attrib_list, configs, config_size, num_config);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLint GL_BINDING_CALL Debug_eglClientWaitSyncKHR(EGLDisplay dpy,
-                                                         EGLSyncKHR sync,
-                                                         EGLint flags,
-                                                         EGLTimeKHR timeout) {
-  GL_SERVICE_LOG("eglClientWaitSyncKHR"
-                 << "(" << dpy << ", " << sync << ", " << flags << ", "
-                 << timeout << ")");
-  DCHECK(g_driver_egl.debug_fn.eglClientWaitSyncKHRFn != nullptr);
-  EGLint result =
-      g_driver_egl.debug_fn.eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglCopyBuffers(EGLDisplay dpy,
-                     EGLSurface surface,
-                     EGLNativePixmapType target) {
-  GL_SERVICE_LOG("eglCopyBuffers"
-                 << "(" << dpy << ", " << surface << ", " << target << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCopyBuffersFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglCopyBuffersFn(dpy, surface, target);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLContext GL_BINDING_CALL
-Debug_eglCreateContext(EGLDisplay dpy,
-                       EGLConfig config,
-                       EGLContext share_context,
-                       const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglCreateContext"
-                 << "(" << dpy << ", " << config << ", " << share_context
-                 << ", " << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreateContextFn != nullptr);
-  EGLContext result = g_driver_egl.debug_fn.eglCreateContextFn(
-      dpy, config, share_context, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLImageKHR GL_BINDING_CALL
-Debug_eglCreateImageKHR(EGLDisplay dpy,
-                        EGLContext ctx,
-                        EGLenum target,
-                        EGLClientBuffer buffer,
-                        const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglCreateImageKHR"
-                 << "(" << dpy << ", " << ctx << ", " << target << ", "
-                 << buffer << ", " << static_cast<const void*>(attrib_list)
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreateImageKHRFn != nullptr);
-  EGLImageKHR result = g_driver_egl.debug_fn.eglCreateImageKHRFn(
-      dpy, ctx, target, buffer, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLSurface GL_BINDING_CALL
-Debug_eglCreatePbufferFromClientBuffer(EGLDisplay dpy,
-                                       EGLenum buftype,
-                                       void* buffer,
-                                       EGLConfig config,
-                                       const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglCreatePbufferFromClientBuffer"
-                 << "(" << dpy << ", " << buftype << ", "
-                 << static_cast<const void*>(buffer) << ", " << config << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreatePbufferFromClientBufferFn != nullptr);
-  EGLSurface result = g_driver_egl.debug_fn.eglCreatePbufferFromClientBufferFn(
-      dpy, buftype, buffer, config, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLSurface GL_BINDING_CALL
-Debug_eglCreatePbufferSurface(EGLDisplay dpy,
-                              EGLConfig config,
-                              const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglCreatePbufferSurface"
-                 << "(" << dpy << ", " << config << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreatePbufferSurfaceFn != nullptr);
-  EGLSurface result =
-      g_driver_egl.debug_fn.eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLSurface GL_BINDING_CALL
-Debug_eglCreatePixmapSurface(EGLDisplay dpy,
-                             EGLConfig config,
-                             EGLNativePixmapType pixmap,
-                             const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglCreatePixmapSurface"
-                 << "(" << dpy << ", " << config << ", " << pixmap << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreatePixmapSurfaceFn != nullptr);
-  EGLSurface result = g_driver_egl.debug_fn.eglCreatePixmapSurfaceFn(
-      dpy, config, pixmap, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLStreamKHR GL_BINDING_CALL
-Debug_eglCreateStreamKHR(EGLDisplay dpy, const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglCreateStreamKHR"
-                 << "(" << dpy << ", " << static_cast<const void*>(attrib_list)
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreateStreamKHRFn != nullptr);
-  EGLStreamKHR result =
-      g_driver_egl.debug_fn.eglCreateStreamKHRFn(dpy, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglCreateStreamProducerD3DTextureNV12ANGLE(EGLDisplay dpy,
-                                                 EGLStreamKHR stream,
-                                                 EGLAttrib* attrib_list) {
-  GL_SERVICE_LOG("eglCreateStreamProducerD3DTextureNV12ANGLE"
-                 << "(" << dpy << ", " << stream << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn !=
-         nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn(
-          dpy, stream, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLSyncKHR GL_BINDING_CALL
-Debug_eglCreateSyncKHR(EGLDisplay dpy,
-                       EGLenum type,
-                       const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglCreateSyncKHR"
-                 << "(" << dpy << ", " << type << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreateSyncKHRFn != nullptr);
-  EGLSyncKHR result =
-      g_driver_egl.debug_fn.eglCreateSyncKHRFn(dpy, type, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLSurface GL_BINDING_CALL
-Debug_eglCreateWindowSurface(EGLDisplay dpy,
-                             EGLConfig config,
-                             EGLNativeWindowType win,
-                             const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglCreateWindowSurface"
-                 << "(" << dpy << ", " << config << ", " << win << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglCreateWindowSurfaceFn != nullptr);
-  EGLSurface result = g_driver_egl.debug_fn.eglCreateWindowSurfaceFn(
-      dpy, config, win, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglDestroyContext(EGLDisplay dpy,
-                                                          EGLContext ctx) {
-  GL_SERVICE_LOG("eglDestroyContext"
-                 << "(" << dpy << ", " << ctx << ")");
-  DCHECK(g_driver_egl.debug_fn.eglDestroyContextFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglDestroyContextFn(dpy, ctx);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglDestroyImageKHR(EGLDisplay dpy,
-                                                           EGLImageKHR image) {
-  GL_SERVICE_LOG("eglDestroyImageKHR"
-                 << "(" << dpy << ", " << image << ")");
-  DCHECK(g_driver_egl.debug_fn.eglDestroyImageKHRFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglDestroyImageKHRFn(dpy, image);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) {
-  GL_SERVICE_LOG("eglDestroyStreamKHR"
-                 << "(" << dpy << ", " << stream << ")");
-  DCHECK(g_driver_egl.debug_fn.eglDestroyStreamKHRFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglDestroyStreamKHRFn(dpy, stream);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglDestroySurface(EGLDisplay dpy,
-                                                          EGLSurface surface) {
-  GL_SERVICE_LOG("eglDestroySurface"
-                 << "(" << dpy << ", " << surface << ")");
-  DCHECK(g_driver_egl.debug_fn.eglDestroySurfaceFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglDestroySurfaceFn(dpy, surface);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglDestroySyncKHR(EGLDisplay dpy,
-                                                          EGLSyncKHR sync) {
-  GL_SERVICE_LOG("eglDestroySyncKHR"
-                 << "(" << dpy << ", " << sync << ")");
-  DCHECK(g_driver_egl.debug_fn.eglDestroySyncKHRFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglDestroySyncKHRFn(dpy, sync);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglGetConfigAttrib(EGLDisplay dpy,
-                                                           EGLConfig config,
-                                                           EGLint attribute,
-                                                           EGLint* value) {
-  GL_SERVICE_LOG("eglGetConfigAttrib"
-                 << "(" << dpy << ", " << config << ", " << attribute << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetConfigAttribFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglGetConfigAttribFn(dpy, config, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglGetConfigs(EGLDisplay dpy,
-                                                      EGLConfig* configs,
-                                                      EGLint config_size,
-                                                      EGLint* num_config) {
-  GL_SERVICE_LOG("eglGetConfigs"
-                 << "(" << dpy << ", " << static_cast<const void*>(configs)
-                 << ", " << config_size << ", "
-                 << static_cast<const void*>(num_config) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetConfigsFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglGetConfigsFn(
-      dpy, configs, config_size, num_config);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLContext GL_BINDING_CALL Debug_eglGetCurrentContext(void) {
-  GL_SERVICE_LOG("eglGetCurrentContext"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetCurrentContextFn != nullptr);
-  EGLContext result = g_driver_egl.debug_fn.eglGetCurrentContextFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLDisplay GL_BINDING_CALL Debug_eglGetCurrentDisplay(void) {
-  GL_SERVICE_LOG("eglGetCurrentDisplay"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetCurrentDisplayFn != nullptr);
-  EGLDisplay result = g_driver_egl.debug_fn.eglGetCurrentDisplayFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLSurface GL_BINDING_CALL Debug_eglGetCurrentSurface(EGLint readdraw) {
-  GL_SERVICE_LOG("eglGetCurrentSurface"
-                 << "(" << readdraw << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetCurrentSurfaceFn != nullptr);
-  EGLSurface result = g_driver_egl.debug_fn.eglGetCurrentSurfaceFn(readdraw);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLDisplay GL_BINDING_CALL
-Debug_eglGetDisplay(EGLNativeDisplayType display_id) {
-  GL_SERVICE_LOG("eglGetDisplay"
-                 << "(" << display_id << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetDisplayFn != nullptr);
-  EGLDisplay result = g_driver_egl.debug_fn.eglGetDisplayFn(display_id);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLint GL_BINDING_CALL Debug_eglGetError(void) {
-  GL_SERVICE_LOG("eglGetError"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetErrorFn != nullptr);
-  EGLint result = g_driver_egl.debug_fn.eglGetErrorFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLDisplay GL_BINDING_CALL
-Debug_eglGetPlatformDisplayEXT(EGLenum platform,
-                               void* native_display,
-                               const EGLint* attrib_list) {
-  GL_SERVICE_LOG("eglGetPlatformDisplayEXT"
-                 << "(" << platform << ", "
-                 << static_cast<const void*>(native_display) << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetPlatformDisplayEXTFn != nullptr);
-  EGLDisplay result = g_driver_egl.debug_fn.eglGetPlatformDisplayEXTFn(
-      platform, native_display, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static __eglMustCastToProperFunctionPointerType GL_BINDING_CALL
-Debug_eglGetProcAddress(const char* procname) {
-  GL_SERVICE_LOG("eglGetProcAddress"
-                 << "(" << procname << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetProcAddressFn != nullptr);
-  __eglMustCastToProperFunctionPointerType result =
-      g_driver_egl.debug_fn.eglGetProcAddressFn(procname);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglGetSyncAttribKHR(EGLDisplay dpy,
-                                                            EGLSyncKHR sync,
-                                                            EGLint attribute,
-                                                            EGLint* value) {
-  GL_SERVICE_LOG("eglGetSyncAttribKHR"
-                 << "(" << dpy << ", " << sync << ", " << attribute << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetSyncAttribKHRFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglGetSyncValuesCHROMIUM(EGLDisplay dpy,
-                               EGLSurface surface,
-                               EGLuint64CHROMIUM* ust,
-                               EGLuint64CHROMIUM* msc,
-                               EGLuint64CHROMIUM* sbc) {
-  GL_SERVICE_LOG("eglGetSyncValuesCHROMIUM"
-                 << "(" << dpy << ", " << surface << ", "
-                 << static_cast<const void*>(ust) << ", "
-                 << static_cast<const void*>(msc) << ", "
-                 << static_cast<const void*>(sbc) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglGetSyncValuesCHROMIUMFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglGetSyncValuesCHROMIUMFn(
-      dpy, surface, ust, msc, sbc);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglImageFlushExternalEXT(EGLDisplay dpy,
-                               EGLImageKHR image,
-                               const EGLAttrib* attrib_list) {
-  GL_SERVICE_LOG("eglImageFlushExternalEXT"
-                 << "(" << dpy << ", " << image << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglImageFlushExternalEXTFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglImageFlushExternalEXTFn(dpy, image, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglInitialize(EGLDisplay dpy,
-                                                      EGLint* major,
-                                                      EGLint* minor) {
-  GL_SERVICE_LOG("eglInitialize"
-                 << "(" << dpy << ", " << static_cast<const void*>(major)
-                 << ", " << static_cast<const void*>(minor) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglInitializeFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglInitializeFn(dpy, major, minor);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglMakeCurrent(EGLDisplay dpy,
-                                                       EGLSurface draw,
-                                                       EGLSurface read,
-                                                       EGLContext ctx) {
-  GL_SERVICE_LOG("eglMakeCurrent"
-                 << "(" << dpy << ", " << draw << ", " << read << ", " << ctx
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglMakeCurrentFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglMakeCurrentFn(dpy, draw, read, ctx);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglPostSubBufferNV(EGLDisplay dpy,
-                                                           EGLSurface surface,
-                                                           EGLint x,
-                                                           EGLint y,
-                                                           EGLint width,
-                                                           EGLint height) {
-  GL_SERVICE_LOG("eglPostSubBufferNV"
-                 << "(" << dpy << ", " << surface << ", " << x << ", " << y
-                 << ", " << width << ", " << height << ")");
-  DCHECK(g_driver_egl.debug_fn.eglPostSubBufferNVFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglPostSubBufferNVFn(
-      dpy, surface, x, y, width, height);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLenum GL_BINDING_CALL Debug_eglQueryAPI(void) {
-  GL_SERVICE_LOG("eglQueryAPI"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglQueryAPIFn != nullptr);
-  EGLenum result = g_driver_egl.debug_fn.eglQueryAPIFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglQueryContext(EGLDisplay dpy,
-                                                        EGLContext ctx,
-                                                        EGLint attribute,
-                                                        EGLint* value) {
-  GL_SERVICE_LOG("eglQueryContext"
-                 << "(" << dpy << ", " << ctx << ", " << attribute << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglQueryContextFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglQueryContextFn(dpy, ctx, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglQueryStreamKHR(EGLDisplay dpy,
-                                                          EGLStreamKHR stream,
-                                                          EGLenum attribute,
-                                                          EGLint* value) {
-  GL_SERVICE_LOG("eglQueryStreamKHR"
-                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglQueryStreamKHRFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglQueryStreamKHRFn(dpy, stream, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglQueryStreamu64KHR(EGLDisplay dpy,
-                           EGLStreamKHR stream,
-                           EGLenum attribute,
-                           EGLuint64KHR* value) {
-  GL_SERVICE_LOG("eglQueryStreamu64KHR"
-                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglQueryStreamu64KHRFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglQueryStreamu64KHRFn(
-      dpy, stream, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static const char* GL_BINDING_CALL Debug_eglQueryString(EGLDisplay dpy,
-                                                        EGLint name) {
-  GL_SERVICE_LOG("eglQueryString"
-                 << "(" << dpy << ", " << name << ")");
-  DCHECK(g_driver_egl.debug_fn.eglQueryStringFn != nullptr);
-  const char* result = g_driver_egl.debug_fn.eglQueryStringFn(dpy, name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglQuerySurface(EGLDisplay dpy,
-                                                        EGLSurface surface,
-                                                        EGLint attribute,
-                                                        EGLint* value) {
-  GL_SERVICE_LOG("eglQuerySurface"
-                 << "(" << dpy << ", " << surface << ", " << attribute << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglQuerySurfaceFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglQuerySurfaceFn(dpy, surface, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglQuerySurfacePointerANGLE(EGLDisplay dpy,
-                                  EGLSurface surface,
-                                  EGLint attribute,
-                                  void** value) {
-  GL_SERVICE_LOG("eglQuerySurfacePointerANGLE"
-                 << "(" << dpy << ", " << surface << ", " << attribute << ", "
-                 << value << ")");
-  DCHECK(g_driver_egl.debug_fn.eglQuerySurfacePointerANGLEFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglQuerySurfacePointerANGLEFn(
-      dpy, surface, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglReleaseTexImage(EGLDisplay dpy,
-                                                           EGLSurface surface,
-                                                           EGLint buffer) {
-  GL_SERVICE_LOG("eglReleaseTexImage"
-                 << "(" << dpy << ", " << surface << ", " << buffer << ")");
-  DCHECK(g_driver_egl.debug_fn.eglReleaseTexImageFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglReleaseTexImageFn(dpy, surface, buffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglReleaseThread(void) {
-  GL_SERVICE_LOG("eglReleaseThread"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglReleaseThreadFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglReleaseThreadFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglStreamAttribKHR(EGLDisplay dpy,
-                                                           EGLStreamKHR stream,
-                                                           EGLenum attribute,
-                                                           EGLint value) {
-  GL_SERVICE_LOG("eglStreamAttribKHR"
-                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
-                 << value << ")");
-  DCHECK(g_driver_egl.debug_fn.eglStreamAttribKHRFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglStreamAttribKHRFn(dpy, stream, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream) {
-  GL_SERVICE_LOG("eglStreamConsumerAcquireKHR"
-                 << "(" << dpy << ", " << stream << ")");
-  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerAcquireKHRFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglStreamConsumerAcquireKHRFn(dpy, stream);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglStreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
-                                                  EGLStreamKHR stream,
-                                                  EGLAttrib* attrib_list) {
-  GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalAttribsNV"
-                 << "(" << dpy << ", " << stream << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn !=
-         nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn(
-          dpy, stream, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy,
-                                            EGLStreamKHR stream) {
-  GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalKHR"
-                 << "(" << dpy << ", " << stream << ")");
-  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalKHRFn !=
-         nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalKHRFn(dpy,
-                                                                    stream);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream) {
-  GL_SERVICE_LOG("eglStreamConsumerReleaseKHR"
-                 << "(" << dpy << ", " << stream << ")");
-  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerReleaseKHRFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglStreamConsumerReleaseKHRFn(dpy, stream);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglStreamPostD3DTextureNV12ANGLE(EGLDisplay dpy,
-                                       EGLStreamKHR stream,
-                                       void* texture,
-                                       const EGLAttrib* attrib_list) {
-  GL_SERVICE_LOG("eglStreamPostD3DTextureNV12ANGLE"
-                 << "(" << dpy << ", " << stream << ", "
-                 << static_cast<const void*>(texture) << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_egl.debug_fn.eglStreamPostD3DTextureNV12ANGLEFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglStreamPostD3DTextureNV12ANGLEFn(
-      dpy, stream, texture, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglSurfaceAttrib(EGLDisplay dpy,
-                                                         EGLSurface surface,
-                                                         EGLint attribute,
-                                                         EGLint value) {
-  GL_SERVICE_LOG("eglSurfaceAttrib"
-                 << "(" << dpy << ", " << surface << ", " << attribute << ", "
-                 << value << ")");
-  DCHECK(g_driver_egl.debug_fn.eglSurfaceAttribFn != nullptr);
-  EGLBoolean result =
-      g_driver_egl.debug_fn.eglSurfaceAttribFn(dpy, surface, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglSwapBuffers(EGLDisplay dpy,
-                                                       EGLSurface surface) {
-  GL_SERVICE_LOG("eglSwapBuffers"
-                 << "(" << dpy << ", " << surface << ")");
-  DCHECK(g_driver_egl.debug_fn.eglSwapBuffersFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglSwapBuffersFn(dpy, surface);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL
-Debug_eglSwapBuffersWithDamageKHR(EGLDisplay dpy,
-                                  EGLSurface surface,
-                                  EGLint* rects,
-                                  EGLint n_rects) {
-  GL_SERVICE_LOG("eglSwapBuffersWithDamageKHR"
-                 << "(" << dpy << ", " << surface << ", "
-                 << static_cast<const void*>(rects) << ", " << n_rects << ")");
-  DCHECK(g_driver_egl.debug_fn.eglSwapBuffersWithDamageKHRFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglSwapBuffersWithDamageKHRFn(
-      dpy, surface, rects, n_rects);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglSwapInterval(EGLDisplay dpy,
-                                                        EGLint interval) {
-  GL_SERVICE_LOG("eglSwapInterval"
-                 << "(" << dpy << ", " << interval << ")");
-  DCHECK(g_driver_egl.debug_fn.eglSwapIntervalFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglSwapIntervalFn(dpy, interval);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglTerminate(EGLDisplay dpy) {
-  GL_SERVICE_LOG("eglTerminate"
-                 << "(" << dpy << ")");
-  DCHECK(g_driver_egl.debug_fn.eglTerminateFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglTerminateFn(dpy);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglWaitClient(void) {
-  GL_SERVICE_LOG("eglWaitClient"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglWaitClientFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglWaitClientFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglWaitGL(void) {
-  GL_SERVICE_LOG("eglWaitGL"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_egl.debug_fn.eglWaitGLFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglWaitGLFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLBoolean GL_BINDING_CALL Debug_eglWaitNative(EGLint engine) {
-  GL_SERVICE_LOG("eglWaitNative"
-                 << "(" << engine << ")");
-  DCHECK(g_driver_egl.debug_fn.eglWaitNativeFn != nullptr);
-  EGLBoolean result = g_driver_egl.debug_fn.eglWaitNativeFn(engine);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static EGLint GL_BINDING_CALL Debug_eglWaitSyncKHR(EGLDisplay dpy,
-                                                   EGLSyncKHR sync,
-                                                   EGLint flags) {
-  GL_SERVICE_LOG("eglWaitSyncKHR"
-                 << "(" << dpy << ", " << sync << ", " << flags << ")");
-  DCHECK(g_driver_egl.debug_fn.eglWaitSyncKHRFn != nullptr);
-  EGLint result = g_driver_egl.debug_fn.eglWaitSyncKHRFn(dpy, sync, flags);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-}  // extern "C"
-
-void DriverEGL::InitializeDebugBindings() {
-  if (!debug_fn.eglBindAPIFn) {
-    debug_fn.eglBindAPIFn = fn.eglBindAPIFn;
-    fn.eglBindAPIFn = Debug_eglBindAPI;
-  }
-  if (!debug_fn.eglBindTexImageFn) {
-    debug_fn.eglBindTexImageFn = fn.eglBindTexImageFn;
-    fn.eglBindTexImageFn = Debug_eglBindTexImage;
-  }
-  if (!debug_fn.eglChooseConfigFn) {
-    debug_fn.eglChooseConfigFn = fn.eglChooseConfigFn;
-    fn.eglChooseConfigFn = Debug_eglChooseConfig;
-  }
-  if (!debug_fn.eglClientWaitSyncKHRFn) {
-    debug_fn.eglClientWaitSyncKHRFn = fn.eglClientWaitSyncKHRFn;
-    fn.eglClientWaitSyncKHRFn = Debug_eglClientWaitSyncKHR;
-  }
-  if (!debug_fn.eglCopyBuffersFn) {
-    debug_fn.eglCopyBuffersFn = fn.eglCopyBuffersFn;
-    fn.eglCopyBuffersFn = Debug_eglCopyBuffers;
-  }
-  if (!debug_fn.eglCreateContextFn) {
-    debug_fn.eglCreateContextFn = fn.eglCreateContextFn;
-    fn.eglCreateContextFn = Debug_eglCreateContext;
-  }
-  if (!debug_fn.eglCreateImageKHRFn) {
-    debug_fn.eglCreateImageKHRFn = fn.eglCreateImageKHRFn;
-    fn.eglCreateImageKHRFn = Debug_eglCreateImageKHR;
-  }
-  if (!debug_fn.eglCreatePbufferFromClientBufferFn) {
-    debug_fn.eglCreatePbufferFromClientBufferFn =
-        fn.eglCreatePbufferFromClientBufferFn;
-    fn.eglCreatePbufferFromClientBufferFn =
-        Debug_eglCreatePbufferFromClientBuffer;
-  }
-  if (!debug_fn.eglCreatePbufferSurfaceFn) {
-    debug_fn.eglCreatePbufferSurfaceFn = fn.eglCreatePbufferSurfaceFn;
-    fn.eglCreatePbufferSurfaceFn = Debug_eglCreatePbufferSurface;
-  }
-  if (!debug_fn.eglCreatePixmapSurfaceFn) {
-    debug_fn.eglCreatePixmapSurfaceFn = fn.eglCreatePixmapSurfaceFn;
-    fn.eglCreatePixmapSurfaceFn = Debug_eglCreatePixmapSurface;
-  }
-  if (!debug_fn.eglCreateStreamKHRFn) {
-    debug_fn.eglCreateStreamKHRFn = fn.eglCreateStreamKHRFn;
-    fn.eglCreateStreamKHRFn = Debug_eglCreateStreamKHR;
-  }
-  if (!debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn) {
-    debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
-        fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn;
-    fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
-        Debug_eglCreateStreamProducerD3DTextureNV12ANGLE;
-  }
-  if (!debug_fn.eglCreateSyncKHRFn) {
-    debug_fn.eglCreateSyncKHRFn = fn.eglCreateSyncKHRFn;
-    fn.eglCreateSyncKHRFn = Debug_eglCreateSyncKHR;
-  }
-  if (!debug_fn.eglCreateWindowSurfaceFn) {
-    debug_fn.eglCreateWindowSurfaceFn = fn.eglCreateWindowSurfaceFn;
-    fn.eglCreateWindowSurfaceFn = Debug_eglCreateWindowSurface;
-  }
-  if (!debug_fn.eglDestroyContextFn) {
-    debug_fn.eglDestroyContextFn = fn.eglDestroyContextFn;
-    fn.eglDestroyContextFn = Debug_eglDestroyContext;
-  }
-  if (!debug_fn.eglDestroyImageKHRFn) {
-    debug_fn.eglDestroyImageKHRFn = fn.eglDestroyImageKHRFn;
-    fn.eglDestroyImageKHRFn = Debug_eglDestroyImageKHR;
-  }
-  if (!debug_fn.eglDestroyStreamKHRFn) {
-    debug_fn.eglDestroyStreamKHRFn = fn.eglDestroyStreamKHRFn;
-    fn.eglDestroyStreamKHRFn = Debug_eglDestroyStreamKHR;
-  }
-  if (!debug_fn.eglDestroySurfaceFn) {
-    debug_fn.eglDestroySurfaceFn = fn.eglDestroySurfaceFn;
-    fn.eglDestroySurfaceFn = Debug_eglDestroySurface;
-  }
-  if (!debug_fn.eglDestroySyncKHRFn) {
-    debug_fn.eglDestroySyncKHRFn = fn.eglDestroySyncKHRFn;
-    fn.eglDestroySyncKHRFn = Debug_eglDestroySyncKHR;
-  }
-  if (!debug_fn.eglGetConfigAttribFn) {
-    debug_fn.eglGetConfigAttribFn = fn.eglGetConfigAttribFn;
-    fn.eglGetConfigAttribFn = Debug_eglGetConfigAttrib;
-  }
-  if (!debug_fn.eglGetConfigsFn) {
-    debug_fn.eglGetConfigsFn = fn.eglGetConfigsFn;
-    fn.eglGetConfigsFn = Debug_eglGetConfigs;
-  }
-  if (!debug_fn.eglGetCurrentContextFn) {
-    debug_fn.eglGetCurrentContextFn = fn.eglGetCurrentContextFn;
-    fn.eglGetCurrentContextFn = Debug_eglGetCurrentContext;
-  }
-  if (!debug_fn.eglGetCurrentDisplayFn) {
-    debug_fn.eglGetCurrentDisplayFn = fn.eglGetCurrentDisplayFn;
-    fn.eglGetCurrentDisplayFn = Debug_eglGetCurrentDisplay;
-  }
-  if (!debug_fn.eglGetCurrentSurfaceFn) {
-    debug_fn.eglGetCurrentSurfaceFn = fn.eglGetCurrentSurfaceFn;
-    fn.eglGetCurrentSurfaceFn = Debug_eglGetCurrentSurface;
-  }
-  if (!debug_fn.eglGetDisplayFn) {
-    debug_fn.eglGetDisplayFn = fn.eglGetDisplayFn;
-    fn.eglGetDisplayFn = Debug_eglGetDisplay;
-  }
-  if (!debug_fn.eglGetErrorFn) {
-    debug_fn.eglGetErrorFn = fn.eglGetErrorFn;
-    fn.eglGetErrorFn = Debug_eglGetError;
-  }
-  if (!debug_fn.eglGetPlatformDisplayEXTFn) {
-    debug_fn.eglGetPlatformDisplayEXTFn = fn.eglGetPlatformDisplayEXTFn;
-    fn.eglGetPlatformDisplayEXTFn = Debug_eglGetPlatformDisplayEXT;
-  }
-  if (!debug_fn.eglGetProcAddressFn) {
-    debug_fn.eglGetProcAddressFn = fn.eglGetProcAddressFn;
-    fn.eglGetProcAddressFn = Debug_eglGetProcAddress;
-  }
-  if (!debug_fn.eglGetSyncAttribKHRFn) {
-    debug_fn.eglGetSyncAttribKHRFn = fn.eglGetSyncAttribKHRFn;
-    fn.eglGetSyncAttribKHRFn = Debug_eglGetSyncAttribKHR;
-  }
-  if (!debug_fn.eglGetSyncValuesCHROMIUMFn) {
-    debug_fn.eglGetSyncValuesCHROMIUMFn = fn.eglGetSyncValuesCHROMIUMFn;
-    fn.eglGetSyncValuesCHROMIUMFn = Debug_eglGetSyncValuesCHROMIUM;
-  }
-  if (!debug_fn.eglImageFlushExternalEXTFn) {
-    debug_fn.eglImageFlushExternalEXTFn = fn.eglImageFlushExternalEXTFn;
-    fn.eglImageFlushExternalEXTFn = Debug_eglImageFlushExternalEXT;
-  }
-  if (!debug_fn.eglInitializeFn) {
-    debug_fn.eglInitializeFn = fn.eglInitializeFn;
-    fn.eglInitializeFn = Debug_eglInitialize;
-  }
-  if (!debug_fn.eglMakeCurrentFn) {
-    debug_fn.eglMakeCurrentFn = fn.eglMakeCurrentFn;
-    fn.eglMakeCurrentFn = Debug_eglMakeCurrent;
-  }
-  if (!debug_fn.eglPostSubBufferNVFn) {
-    debug_fn.eglPostSubBufferNVFn = fn.eglPostSubBufferNVFn;
-    fn.eglPostSubBufferNVFn = Debug_eglPostSubBufferNV;
-  }
-  if (!debug_fn.eglQueryAPIFn) {
-    debug_fn.eglQueryAPIFn = fn.eglQueryAPIFn;
-    fn.eglQueryAPIFn = Debug_eglQueryAPI;
-  }
-  if (!debug_fn.eglQueryContextFn) {
-    debug_fn.eglQueryContextFn = fn.eglQueryContextFn;
-    fn.eglQueryContextFn = Debug_eglQueryContext;
-  }
-  if (!debug_fn.eglQueryStreamKHRFn) {
-    debug_fn.eglQueryStreamKHRFn = fn.eglQueryStreamKHRFn;
-    fn.eglQueryStreamKHRFn = Debug_eglQueryStreamKHR;
-  }
-  if (!debug_fn.eglQueryStreamu64KHRFn) {
-    debug_fn.eglQueryStreamu64KHRFn = fn.eglQueryStreamu64KHRFn;
-    fn.eglQueryStreamu64KHRFn = Debug_eglQueryStreamu64KHR;
-  }
-  if (!debug_fn.eglQueryStringFn) {
-    debug_fn.eglQueryStringFn = fn.eglQueryStringFn;
-    fn.eglQueryStringFn = Debug_eglQueryString;
-  }
-  if (!debug_fn.eglQuerySurfaceFn) {
-    debug_fn.eglQuerySurfaceFn = fn.eglQuerySurfaceFn;
-    fn.eglQuerySurfaceFn = Debug_eglQuerySurface;
-  }
-  if (!debug_fn.eglQuerySurfacePointerANGLEFn) {
-    debug_fn.eglQuerySurfacePointerANGLEFn = fn.eglQuerySurfacePointerANGLEFn;
-    fn.eglQuerySurfacePointerANGLEFn = Debug_eglQuerySurfacePointerANGLE;
-  }
-  if (!debug_fn.eglReleaseTexImageFn) {
-    debug_fn.eglReleaseTexImageFn = fn.eglReleaseTexImageFn;
-    fn.eglReleaseTexImageFn = Debug_eglReleaseTexImage;
-  }
-  if (!debug_fn.eglReleaseThreadFn) {
-    debug_fn.eglReleaseThreadFn = fn.eglReleaseThreadFn;
-    fn.eglReleaseThreadFn = Debug_eglReleaseThread;
-  }
-  if (!debug_fn.eglStreamAttribKHRFn) {
-    debug_fn.eglStreamAttribKHRFn = fn.eglStreamAttribKHRFn;
-    fn.eglStreamAttribKHRFn = Debug_eglStreamAttribKHR;
-  }
-  if (!debug_fn.eglStreamConsumerAcquireKHRFn) {
-    debug_fn.eglStreamConsumerAcquireKHRFn = fn.eglStreamConsumerAcquireKHRFn;
-    fn.eglStreamConsumerAcquireKHRFn = Debug_eglStreamConsumerAcquireKHR;
-  }
-  if (!debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn) {
-    debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
-        fn.eglStreamConsumerGLTextureExternalAttribsNVFn;
-    fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
-        Debug_eglStreamConsumerGLTextureExternalAttribsNV;
-  }
-  if (!debug_fn.eglStreamConsumerGLTextureExternalKHRFn) {
-    debug_fn.eglStreamConsumerGLTextureExternalKHRFn =
-        fn.eglStreamConsumerGLTextureExternalKHRFn;
-    fn.eglStreamConsumerGLTextureExternalKHRFn =
-        Debug_eglStreamConsumerGLTextureExternalKHR;
-  }
-  if (!debug_fn.eglStreamConsumerReleaseKHRFn) {
-    debug_fn.eglStreamConsumerReleaseKHRFn = fn.eglStreamConsumerReleaseKHRFn;
-    fn.eglStreamConsumerReleaseKHRFn = Debug_eglStreamConsumerReleaseKHR;
-  }
-  if (!debug_fn.eglStreamPostD3DTextureNV12ANGLEFn) {
-    debug_fn.eglStreamPostD3DTextureNV12ANGLEFn =
-        fn.eglStreamPostD3DTextureNV12ANGLEFn;
-    fn.eglStreamPostD3DTextureNV12ANGLEFn =
-        Debug_eglStreamPostD3DTextureNV12ANGLE;
-  }
-  if (!debug_fn.eglSurfaceAttribFn) {
-    debug_fn.eglSurfaceAttribFn = fn.eglSurfaceAttribFn;
-    fn.eglSurfaceAttribFn = Debug_eglSurfaceAttrib;
-  }
-  if (!debug_fn.eglSwapBuffersFn) {
-    debug_fn.eglSwapBuffersFn = fn.eglSwapBuffersFn;
-    fn.eglSwapBuffersFn = Debug_eglSwapBuffers;
-  }
-  if (!debug_fn.eglSwapBuffersWithDamageKHRFn) {
-    debug_fn.eglSwapBuffersWithDamageKHRFn = fn.eglSwapBuffersWithDamageKHRFn;
-    fn.eglSwapBuffersWithDamageKHRFn = Debug_eglSwapBuffersWithDamageKHR;
-  }
-  if (!debug_fn.eglSwapIntervalFn) {
-    debug_fn.eglSwapIntervalFn = fn.eglSwapIntervalFn;
-    fn.eglSwapIntervalFn = Debug_eglSwapInterval;
-  }
-  if (!debug_fn.eglTerminateFn) {
-    debug_fn.eglTerminateFn = fn.eglTerminateFn;
-    fn.eglTerminateFn = Debug_eglTerminate;
-  }
-  if (!debug_fn.eglWaitClientFn) {
-    debug_fn.eglWaitClientFn = fn.eglWaitClientFn;
-    fn.eglWaitClientFn = Debug_eglWaitClient;
-  }
-  if (!debug_fn.eglWaitGLFn) {
-    debug_fn.eglWaitGLFn = fn.eglWaitGLFn;
-    fn.eglWaitGLFn = Debug_eglWaitGL;
-  }
-  if (!debug_fn.eglWaitNativeFn) {
-    debug_fn.eglWaitNativeFn = fn.eglWaitNativeFn;
-    fn.eglWaitNativeFn = Debug_eglWaitNative;
-  }
-  if (!debug_fn.eglWaitSyncKHRFn) {
-    debug_fn.eglWaitSyncKHRFn = fn.eglWaitSyncKHRFn;
-    fn.eglWaitSyncKHRFn = Debug_eglWaitSyncKHR;
-  }
-  g_debugBindingsInitialized = true;
 }
 
 void DriverEGL::ClearBindings() {
@@ -2066,4 +1056,648 @@ EGLint TraceEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
   return egl_api_->eglWaitSyncKHRFn(dpy, sync, flags);
 }
 
+EGLBoolean DebugEGLApi::eglBindAPIFn(EGLenum api) {
+  GL_SERVICE_LOG("eglBindAPI"
+                 << "(" << api << ")");
+  EGLBoolean result = egl_api_->eglBindAPIFn(api);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglBindTexImageFn(EGLDisplay dpy,
+                                          EGLSurface surface,
+                                          EGLint buffer) {
+  GL_SERVICE_LOG("eglBindTexImage"
+                 << "(" << dpy << ", " << surface << ", " << buffer << ")");
+  EGLBoolean result = egl_api_->eglBindTexImageFn(dpy, surface, buffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglChooseConfigFn(EGLDisplay dpy,
+                                          const EGLint* attrib_list,
+                                          EGLConfig* configs,
+                                          EGLint config_size,
+                                          EGLint* num_config) {
+  GL_SERVICE_LOG("eglChooseConfig"
+                 << "(" << dpy << ", " << static_cast<const void*>(attrib_list)
+                 << ", " << static_cast<const void*>(configs) << ", "
+                 << config_size << ", " << static_cast<const void*>(num_config)
+                 << ")");
+  EGLBoolean result = egl_api_->eglChooseConfigFn(dpy, attrib_list, configs,
+                                                  config_size, num_config);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLint DebugEGLApi::eglClientWaitSyncKHRFn(EGLDisplay dpy,
+                                           EGLSyncKHR sync,
+                                           EGLint flags,
+                                           EGLTimeKHR timeout) {
+  GL_SERVICE_LOG("eglClientWaitSyncKHR"
+                 << "(" << dpy << ", " << sync << ", " << flags << ", "
+                 << timeout << ")");
+  EGLint result = egl_api_->eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglCopyBuffersFn(EGLDisplay dpy,
+                                         EGLSurface surface,
+                                         EGLNativePixmapType target) {
+  GL_SERVICE_LOG("eglCopyBuffers"
+                 << "(" << dpy << ", " << surface << ", " << target << ")");
+  EGLBoolean result = egl_api_->eglCopyBuffersFn(dpy, surface, target);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLContext DebugEGLApi::eglCreateContextFn(EGLDisplay dpy,
+                                           EGLConfig config,
+                                           EGLContext share_context,
+                                           const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreateContext"
+                 << "(" << dpy << ", " << config << ", " << share_context
+                 << ", " << static_cast<const void*>(attrib_list) << ")");
+  EGLContext result =
+      egl_api_->eglCreateContextFn(dpy, config, share_context, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLImageKHR DebugEGLApi::eglCreateImageKHRFn(EGLDisplay dpy,
+                                             EGLContext ctx,
+                                             EGLenum target,
+                                             EGLClientBuffer buffer,
+                                             const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreateImageKHR"
+                 << "(" << dpy << ", " << ctx << ", " << target << ", "
+                 << buffer << ", " << static_cast<const void*>(attrib_list)
+                 << ")");
+  EGLImageKHR result =
+      egl_api_->eglCreateImageKHRFn(dpy, ctx, target, buffer, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLSurface DebugEGLApi::eglCreatePbufferFromClientBufferFn(
+    EGLDisplay dpy,
+    EGLenum buftype,
+    void* buffer,
+    EGLConfig config,
+    const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreatePbufferFromClientBuffer"
+                 << "(" << dpy << ", " << buftype << ", "
+                 << static_cast<const void*>(buffer) << ", " << config << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLSurface result = egl_api_->eglCreatePbufferFromClientBufferFn(
+      dpy, buftype, buffer, config, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLSurface DebugEGLApi::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
+                                                  EGLConfig config,
+                                                  const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreatePbufferSurface"
+                 << "(" << dpy << ", " << config << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLSurface result =
+      egl_api_->eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLSurface DebugEGLApi::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
+                                                 EGLConfig config,
+                                                 EGLNativePixmapType pixmap,
+                                                 const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreatePixmapSurface"
+                 << "(" << dpy << ", " << config << ", " << pixmap << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLSurface result =
+      egl_api_->eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLStreamKHR DebugEGLApi::eglCreateStreamKHRFn(EGLDisplay dpy,
+                                               const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreateStreamKHR"
+                 << "(" << dpy << ", " << static_cast<const void*>(attrib_list)
+                 << ")");
+  EGLStreamKHR result = egl_api_->eglCreateStreamKHRFn(dpy, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglCreateStreamProducerD3DTextureNV12ANGLEFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglCreateStreamProducerD3DTextureNV12ANGLE"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLBoolean result = egl_api_->eglCreateStreamProducerD3DTextureNV12ANGLEFn(
+      dpy, stream, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLSyncKHR DebugEGLApi::eglCreateSyncKHRFn(EGLDisplay dpy,
+                                           EGLenum type,
+                                           const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreateSyncKHR"
+                 << "(" << dpy << ", " << type << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLSyncKHR result = egl_api_->eglCreateSyncKHRFn(dpy, type, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLSurface DebugEGLApi::eglCreateWindowSurfaceFn(EGLDisplay dpy,
+                                                 EGLConfig config,
+                                                 EGLNativeWindowType win,
+                                                 const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreateWindowSurface"
+                 << "(" << dpy << ", " << config << ", " << win << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLSurface result =
+      egl_api_->eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
+  GL_SERVICE_LOG("eglDestroyContext"
+                 << "(" << dpy << ", " << ctx << ")");
+  EGLBoolean result = egl_api_->eglDestroyContextFn(dpy, ctx);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglDestroyImageKHRFn(EGLDisplay dpy,
+                                             EGLImageKHR image) {
+  GL_SERVICE_LOG("eglDestroyImageKHR"
+                 << "(" << dpy << ", " << image << ")");
+  EGLBoolean result = egl_api_->eglDestroyImageKHRFn(dpy, image);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglDestroyStreamKHRFn(EGLDisplay dpy,
+                                              EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglDestroyStreamKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  EGLBoolean result = egl_api_->eglDestroyStreamKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglDestroySurfaceFn(EGLDisplay dpy,
+                                            EGLSurface surface) {
+  GL_SERVICE_LOG("eglDestroySurface"
+                 << "(" << dpy << ", " << surface << ")");
+  EGLBoolean result = egl_api_->eglDestroySurfaceFn(dpy, surface);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
+  GL_SERVICE_LOG("eglDestroySyncKHR"
+                 << "(" << dpy << ", " << sync << ")");
+  EGLBoolean result = egl_api_->eglDestroySyncKHRFn(dpy, sync);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglGetConfigAttribFn(EGLDisplay dpy,
+                                             EGLConfig config,
+                                             EGLint attribute,
+                                             EGLint* value) {
+  GL_SERVICE_LOG("eglGetConfigAttrib"
+                 << "(" << dpy << ", " << config << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  EGLBoolean result =
+      egl_api_->eglGetConfigAttribFn(dpy, config, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglGetConfigsFn(EGLDisplay dpy,
+                                        EGLConfig* configs,
+                                        EGLint config_size,
+                                        EGLint* num_config) {
+  GL_SERVICE_LOG("eglGetConfigs"
+                 << "(" << dpy << ", " << static_cast<const void*>(configs)
+                 << ", " << config_size << ", "
+                 << static_cast<const void*>(num_config) << ")");
+  EGLBoolean result =
+      egl_api_->eglGetConfigsFn(dpy, configs, config_size, num_config);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLContext DebugEGLApi::eglGetCurrentContextFn(void) {
+  GL_SERVICE_LOG("eglGetCurrentContext"
+                 << "("
+                 << ")");
+  EGLContext result = egl_api_->eglGetCurrentContextFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLDisplay DebugEGLApi::eglGetCurrentDisplayFn(void) {
+  GL_SERVICE_LOG("eglGetCurrentDisplay"
+                 << "("
+                 << ")");
+  EGLDisplay result = egl_api_->eglGetCurrentDisplayFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLSurface DebugEGLApi::eglGetCurrentSurfaceFn(EGLint readdraw) {
+  GL_SERVICE_LOG("eglGetCurrentSurface"
+                 << "(" << readdraw << ")");
+  EGLSurface result = egl_api_->eglGetCurrentSurfaceFn(readdraw);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLDisplay DebugEGLApi::eglGetDisplayFn(EGLNativeDisplayType display_id) {
+  GL_SERVICE_LOG("eglGetDisplay"
+                 << "(" << display_id << ")");
+  EGLDisplay result = egl_api_->eglGetDisplayFn(display_id);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLint DebugEGLApi::eglGetErrorFn(void) {
+  GL_SERVICE_LOG("eglGetError"
+                 << "("
+                 << ")");
+  EGLint result = egl_api_->eglGetErrorFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLDisplay DebugEGLApi::eglGetPlatformDisplayEXTFn(EGLenum platform,
+                                                   void* native_display,
+                                                   const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglGetPlatformDisplayEXT"
+                 << "(" << platform << ", "
+                 << static_cast<const void*>(native_display) << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLDisplay result = egl_api_->eglGetPlatformDisplayEXTFn(
+      platform, native_display, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+__eglMustCastToProperFunctionPointerType DebugEGLApi::eglGetProcAddressFn(
+    const char* procname) {
+  GL_SERVICE_LOG("eglGetProcAddress"
+                 << "(" << procname << ")");
+  __eglMustCastToProperFunctionPointerType result =
+      egl_api_->eglGetProcAddressFn(procname);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglGetSyncAttribKHRFn(EGLDisplay dpy,
+                                              EGLSyncKHR sync,
+                                              EGLint attribute,
+                                              EGLint* value) {
+  GL_SERVICE_LOG("eglGetSyncAttribKHR"
+                 << "(" << dpy << ", " << sync << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  EGLBoolean result =
+      egl_api_->eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
+                                                   EGLSurface surface,
+                                                   EGLuint64CHROMIUM* ust,
+                                                   EGLuint64CHROMIUM* msc,
+                                                   EGLuint64CHROMIUM* sbc) {
+  GL_SERVICE_LOG("eglGetSyncValuesCHROMIUM"
+                 << "(" << dpy << ", " << surface << ", "
+                 << static_cast<const void*>(ust) << ", "
+                 << static_cast<const void*>(msc) << ", "
+                 << static_cast<const void*>(sbc) << ")");
+  EGLBoolean result =
+      egl_api_->eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglImageFlushExternalEXTFn(
+    EGLDisplay dpy,
+    EGLImageKHR image,
+    const EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglImageFlushExternalEXT"
+                 << "(" << dpy << ", " << image << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLBoolean result =
+      egl_api_->eglImageFlushExternalEXTFn(dpy, image, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglInitializeFn(EGLDisplay dpy,
+                                        EGLint* major,
+                                        EGLint* minor) {
+  GL_SERVICE_LOG("eglInitialize"
+                 << "(" << dpy << ", " << static_cast<const void*>(major)
+                 << ", " << static_cast<const void*>(minor) << ")");
+  EGLBoolean result = egl_api_->eglInitializeFn(dpy, major, minor);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglMakeCurrentFn(EGLDisplay dpy,
+                                         EGLSurface draw,
+                                         EGLSurface read,
+                                         EGLContext ctx) {
+  GL_SERVICE_LOG("eglMakeCurrent"
+                 << "(" << dpy << ", " << draw << ", " << read << ", " << ctx
+                 << ")");
+  EGLBoolean result = egl_api_->eglMakeCurrentFn(dpy, draw, read, ctx);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglPostSubBufferNVFn(EGLDisplay dpy,
+                                             EGLSurface surface,
+                                             EGLint x,
+                                             EGLint y,
+                                             EGLint width,
+                                             EGLint height) {
+  GL_SERVICE_LOG("eglPostSubBufferNV"
+                 << "(" << dpy << ", " << surface << ", " << x << ", " << y
+                 << ", " << width << ", " << height << ")");
+  EGLBoolean result =
+      egl_api_->eglPostSubBufferNVFn(dpy, surface, x, y, width, height);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLenum DebugEGLApi::eglQueryAPIFn(void) {
+  GL_SERVICE_LOG("eglQueryAPI"
+                 << "("
+                 << ")");
+  EGLenum result = egl_api_->eglQueryAPIFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglQueryContextFn(EGLDisplay dpy,
+                                          EGLContext ctx,
+                                          EGLint attribute,
+                                          EGLint* value) {
+  GL_SERVICE_LOG("eglQueryContext"
+                 << "(" << dpy << ", " << ctx << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  EGLBoolean result = egl_api_->eglQueryContextFn(dpy, ctx, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglQueryStreamKHRFn(EGLDisplay dpy,
+                                            EGLStreamKHR stream,
+                                            EGLenum attribute,
+                                            EGLint* value) {
+  GL_SERVICE_LOG("eglQueryStreamKHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  EGLBoolean result =
+      egl_api_->eglQueryStreamKHRFn(dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglQueryStreamu64KHRFn(EGLDisplay dpy,
+                                               EGLStreamKHR stream,
+                                               EGLenum attribute,
+                                               EGLuint64KHR* value) {
+  GL_SERVICE_LOG("eglQueryStreamu64KHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  EGLBoolean result =
+      egl_api_->eglQueryStreamu64KHRFn(dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+const char* DebugEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
+  GL_SERVICE_LOG("eglQueryString"
+                 << "(" << dpy << ", " << name << ")");
+  const char* result = egl_api_->eglQueryStringFn(dpy, name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglQuerySurfaceFn(EGLDisplay dpy,
+                                          EGLSurface surface,
+                                          EGLint attribute,
+                                          EGLint* value) {
+  GL_SERVICE_LOG("eglQuerySurface"
+                 << "(" << dpy << ", " << surface << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  EGLBoolean result =
+      egl_api_->eglQuerySurfaceFn(dpy, surface, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
+                                                      EGLSurface surface,
+                                                      EGLint attribute,
+                                                      void** value) {
+  GL_SERVICE_LOG("eglQuerySurfacePointerANGLE"
+                 << "(" << dpy << ", " << surface << ", " << attribute << ", "
+                 << value << ")");
+  EGLBoolean result =
+      egl_api_->eglQuerySurfacePointerANGLEFn(dpy, surface, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglReleaseTexImageFn(EGLDisplay dpy,
+                                             EGLSurface surface,
+                                             EGLint buffer) {
+  GL_SERVICE_LOG("eglReleaseTexImage"
+                 << "(" << dpy << ", " << surface << ", " << buffer << ")");
+  EGLBoolean result = egl_api_->eglReleaseTexImageFn(dpy, surface, buffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglReleaseThreadFn(void) {
+  GL_SERVICE_LOG("eglReleaseThread"
+                 << "("
+                 << ")");
+  EGLBoolean result = egl_api_->eglReleaseThreadFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglStreamAttribKHRFn(EGLDisplay dpy,
+                                             EGLStreamKHR stream,
+                                             EGLenum attribute,
+                                             EGLint value) {
+  GL_SERVICE_LOG("eglStreamAttribKHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << value << ")");
+  EGLBoolean result =
+      egl_api_->eglStreamAttribKHRFn(dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
+                                                      EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerAcquireKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  EGLBoolean result = egl_api_->eglStreamConsumerAcquireKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglStreamConsumerGLTextureExternalAttribsNVFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalAttribsNV"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLBoolean result = egl_api_->eglStreamConsumerGLTextureExternalAttribsNVFn(
+      dpy, stream, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglStreamConsumerGLTextureExternalKHRFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  EGLBoolean result =
+      egl_api_->eglStreamConsumerGLTextureExternalKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
+                                                      EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerReleaseKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  EGLBoolean result = egl_api_->eglStreamConsumerReleaseKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglStreamPostD3DTextureNV12ANGLEFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    void* texture,
+    const EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglStreamPostD3DTextureNV12ANGLE"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(texture) << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  EGLBoolean result = egl_api_->eglStreamPostD3DTextureNV12ANGLEFn(
+      dpy, stream, texture, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglSurfaceAttribFn(EGLDisplay dpy,
+                                           EGLSurface surface,
+                                           EGLint attribute,
+                                           EGLint value) {
+  GL_SERVICE_LOG("eglSurfaceAttrib"
+                 << "(" << dpy << ", " << surface << ", " << attribute << ", "
+                 << value << ")");
+  EGLBoolean result =
+      egl_api_->eglSurfaceAttribFn(dpy, surface, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
+  GL_SERVICE_LOG("eglSwapBuffers"
+                 << "(" << dpy << ", " << surface << ")");
+  EGLBoolean result = egl_api_->eglSwapBuffersFn(dpy, surface);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
+                                                      EGLSurface surface,
+                                                      EGLint* rects,
+                                                      EGLint n_rects) {
+  GL_SERVICE_LOG("eglSwapBuffersWithDamageKHR"
+                 << "(" << dpy << ", " << surface << ", "
+                 << static_cast<const void*>(rects) << ", " << n_rects << ")");
+  EGLBoolean result =
+      egl_api_->eglSwapBuffersWithDamageKHRFn(dpy, surface, rects, n_rects);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
+  GL_SERVICE_LOG("eglSwapInterval"
+                 << "(" << dpy << ", " << interval << ")");
+  EGLBoolean result = egl_api_->eglSwapIntervalFn(dpy, interval);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglTerminateFn(EGLDisplay dpy) {
+  GL_SERVICE_LOG("eglTerminate"
+                 << "(" << dpy << ")");
+  EGLBoolean result = egl_api_->eglTerminateFn(dpy);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglWaitClientFn(void) {
+  GL_SERVICE_LOG("eglWaitClient"
+                 << "("
+                 << ")");
+  EGLBoolean result = egl_api_->eglWaitClientFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglWaitGLFn(void) {
+  GL_SERVICE_LOG("eglWaitGL"
+                 << "("
+                 << ")");
+  EGLBoolean result = egl_api_->eglWaitGLFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLBoolean DebugEGLApi::eglWaitNativeFn(EGLint engine) {
+  GL_SERVICE_LOG("eglWaitNative"
+                 << "(" << engine << ")");
+  EGLBoolean result = egl_api_->eglWaitNativeFn(engine);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+EGLint DebugEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
+                                     EGLSyncKHR sync,
+                                     EGLint flags) {
+  GL_SERVICE_LOG("eglWaitSyncKHR"
+                 << "(" << dpy << ", " << sync << ", " << flags << ")");
+  EGLint result = egl_api_->eglWaitSyncKHRFn(dpy, sync, flags);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 }  // namespace gl
diff --git a/chromium/ui/gl/gl_bindings_autogen_gl.cc b/chromium/ui/gl/gl_bindings_autogen_gl.cc
index 55f17a8c713..5257bd5dc32 100644
--- a/chromium/ui/gl/gl_bindings_autogen_gl.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_gl.cc
@@ -20,9 +20,6 @@
 
 namespace gl {
 
-static bool g_debugBindingsInitialized;
-DriverGL g_driver_gl;
-
 void DriverGL::InitializeStaticBindings() {
   fn.glActiveTextureFn = reinterpret_cast<glActiveTextureProc>(
       GetGLProcAddress("glActiveTexture"));
@@ -541,11 +538,10 @@ void DriverGL::InitializeStaticBindings() {
   fn.glWaitSyncFn = 0;
 }
 
-void DriverGL::InitializeDynamicBindings(GLContext* context) {
-  DCHECK(context && context->IsCurrent(NULL));
-  const GLVersionInfo* ver = context->GetVersionInfo();
-  ALLOW_UNUSED_LOCAL(ver);
-  std::string extensions = context->GetExtensions() + " ";
+void DriverGL::InitializeDynamicBindings(
+    const GLVersionInfo* ver,
+    const std::string& context_extensions) {
+  std::string extensions = context_extensions + " ";
   ALLOW_UNUSED_LOCAL(extensions);
 
   ext.b_GL_ANGLE_framebuffer_blit =
@@ -675,14 +671,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
   ext.b_GL_OES_vertex_array_object =
       extensions.find("GL_OES_vertex_array_object ") != std::string::npos;
 
-  debug_fn.glApplyFramebufferAttachmentCMAAINTELFn = 0;
   if (ext.b_GL_INTEL_framebuffer_CMAA) {
     fn.glApplyFramebufferAttachmentCMAAINTELFn =
         reinterpret_cast<glApplyFramebufferAttachmentCMAAINTELProc>(
             GetGLProcAddress("glApplyFramebufferAttachmentCMAAINTEL"));
   }
 
-  debug_fn.glBeginQueryFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glBeginQueryFn =
         reinterpret_cast<glBeginQueryProc>(GetGLProcAddress("glBeginQuery"));
@@ -695,7 +689,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         reinterpret_cast<glBeginQueryProc>(GetGLProcAddress("glBeginQueryEXT"));
   }
 
-  debug_fn.glBeginTransformFeedbackFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glBeginTransformFeedbackFn =
         reinterpret_cast<glBeginTransformFeedbackProc>(
@@ -706,7 +699,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glBeginTransformFeedbackEXT"));
   }
 
-  debug_fn.glBindBufferBaseFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glBindBufferBaseFn = reinterpret_cast<glBindBufferBaseProc>(
         GetGLProcAddress("glBindBufferBase"));
@@ -715,7 +707,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBindBufferBaseEXT"));
   }
 
-  debug_fn.glBindBufferRangeFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glBindBufferRangeFn = reinterpret_cast<glBindBufferRangeProc>(
         GetGLProcAddress("glBindBufferRange"));
@@ -724,7 +715,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBindBufferRangeEXT"));
   }
 
-  debug_fn.glBindFragDataLocationFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ext.b_GL_ARB_blend_func_extended) {
     fn.glBindFragDataLocationFn = reinterpret_cast<glBindFragDataLocationProc>(
         GetGLProcAddress("glBindFragDataLocation"));
@@ -733,7 +723,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBindFragDataLocationEXT"));
   }
 
-  debug_fn.glBindFragDataLocationIndexedFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_blend_func_extended) {
     fn.glBindFragDataLocationIndexedFn =
         reinterpret_cast<glBindFragDataLocationIndexedProc>(
@@ -744,7 +733,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glBindFragDataLocationIndexedEXT"));
   }
 
-  debug_fn.glBindFramebufferEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glBindFramebufferEXTFn = reinterpret_cast<glBindFramebufferEXTProc>(
         GetGLProcAddress("glBindFramebuffer"));
@@ -753,7 +741,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBindFramebufferEXT"));
   }
 
-  debug_fn.glBindImageTextureEXTFn = 0;
   if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 1u) ||
       ext.b_GL_ARB_shader_image_load_store) {
     fn.glBindImageTextureEXTFn = reinterpret_cast<glBindImageTextureEXTProc>(
@@ -763,7 +750,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBindImageTextureEXT"));
   }
 
-  debug_fn.glBindRenderbufferEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glBindRenderbufferEXTFn = reinterpret_cast<glBindRenderbufferEXTProc>(
         GetGLProcAddress("glBindRenderbuffer"));
@@ -772,14 +758,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBindRenderbufferEXT"));
   }
 
-  debug_fn.glBindSamplerFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glBindSamplerFn =
         reinterpret_cast<glBindSamplerProc>(GetGLProcAddress("glBindSampler"));
   }
 
-  debug_fn.glBindTransformFeedbackFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
       ext.b_GL_ARB_transform_feedback2) {
     fn.glBindTransformFeedbackFn =
@@ -787,14 +771,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glBindTransformFeedback"));
   }
 
-  debug_fn.glBindUniformLocationCHROMIUMFn = 0;
   if (ext.b_GL_CHROMIUM_bind_uniform_location) {
     fn.glBindUniformLocationCHROMIUMFn =
         reinterpret_cast<glBindUniformLocationCHROMIUMProc>(
             GetGLProcAddress("glBindUniformLocationCHROMIUM"));
   }
 
-  debug_fn.glBindVertexArrayOESFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_vertex_array_object) {
     fn.glBindVertexArrayOESFn = reinterpret_cast<glBindVertexArrayOESProc>(
@@ -807,7 +789,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBindVertexArrayAPPLE"));
   }
 
-  debug_fn.glBlendBarrierKHRFn = 0;
   if (ext.b_GL_NV_blend_equation_advanced) {
     fn.glBlendBarrierKHRFn = reinterpret_cast<glBlendBarrierKHRProc>(
         GetGLProcAddress("glBlendBarrierNV"));
@@ -816,13 +797,11 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBlendBarrierKHR"));
   }
 
-  debug_fn.glBlitFramebufferFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glBlitFramebufferFn = reinterpret_cast<glBlitFramebufferProc>(
         GetGLProcAddress("glBlitFramebuffer"));
   }
 
-  debug_fn.glBlitFramebufferANGLEFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glBlitFramebufferANGLEFn = reinterpret_cast<glBlitFramebufferANGLEProc>(
         GetGLProcAddress("glBlitFramebuffer"));
@@ -831,7 +810,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBlitFramebufferANGLE"));
   }
 
-  debug_fn.glBlitFramebufferEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glBlitFramebufferEXTFn = reinterpret_cast<glBlitFramebufferEXTProc>(
         GetGLProcAddress("glBlitFramebuffer"));
@@ -840,7 +818,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glBlitFramebufferEXT"));
   }
 
-  debug_fn.glCheckFramebufferStatusEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glCheckFramebufferStatusEXTFn =
         reinterpret_cast<glCheckFramebufferStatusEXTProc>(
@@ -851,44 +828,37 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glCheckFramebufferStatusEXT"));
   }
 
-  debug_fn.glClearBufferfiFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glClearBufferfiFn = reinterpret_cast<glClearBufferfiProc>(
         GetGLProcAddress("glClearBufferfi"));
   }
 
-  debug_fn.glClearBufferfvFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glClearBufferfvFn = reinterpret_cast<glClearBufferfvProc>(
         GetGLProcAddress("glClearBufferfv"));
   }
 
-  debug_fn.glClearBufferivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glClearBufferivFn = reinterpret_cast<glClearBufferivProc>(
         GetGLProcAddress("glClearBufferiv"));
   }
 
-  debug_fn.glClearBufferuivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glClearBufferuivFn = reinterpret_cast<glClearBufferuivProc>(
         GetGLProcAddress("glClearBufferuiv"));
   }
 
-  debug_fn.glClearDepthfFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
     fn.glClearDepthfFn =
         reinterpret_cast<glClearDepthfProc>(GetGLProcAddress("glClearDepthf"));
   }
 
-  debug_fn.glClientWaitSyncFn = 0;
   if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sync) {
     fn.glClientWaitSyncFn = reinterpret_cast<glClientWaitSyncProc>(
         GetGLProcAddress("glClientWaitSync"));
   }
 
-  debug_fn.glCompressedCopyTextureCHROMIUMFn = 0;
   if (ext.b_GL_CHROMIUM_copy_compressed_texture ||
       ext.b_GL_CHROMIUM_compressed_copy_texture) {
     fn.glCompressedCopyTextureCHROMIUMFn =
@@ -896,77 +866,65 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glCompressedCopyTextureCHROMIUM"));
   }
 
-  debug_fn.glCompressedTexImage3DFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glCompressedTexImage3DFn = reinterpret_cast<glCompressedTexImage3DProc>(
         GetGLProcAddress("glCompressedTexImage3D"));
   }
 
-  debug_fn.glCompressedTexSubImage3DFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glCompressedTexSubImage3DFn =
         reinterpret_cast<glCompressedTexSubImage3DProc>(
             GetGLProcAddress("glCompressedTexSubImage3D"));
   }
 
-  debug_fn.glCopyBufferSubDataFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glCopyBufferSubDataFn = reinterpret_cast<glCopyBufferSubDataProc>(
         GetGLProcAddress("glCopyBufferSubData"));
   }
 
-  debug_fn.glCopySubTextureCHROMIUMFn = 0;
   if (ext.b_GL_CHROMIUM_copy_texture) {
     fn.glCopySubTextureCHROMIUMFn =
         reinterpret_cast<glCopySubTextureCHROMIUMProc>(
             GetGLProcAddress("glCopySubTextureCHROMIUM"));
   }
 
-  debug_fn.glCopyTexSubImage3DFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glCopyTexSubImage3DFn = reinterpret_cast<glCopyTexSubImage3DProc>(
         GetGLProcAddress("glCopyTexSubImage3D"));
   }
 
-  debug_fn.glCopyTextureCHROMIUMFn = 0;
   if (ext.b_GL_CHROMIUM_copy_texture) {
     fn.glCopyTextureCHROMIUMFn = reinterpret_cast<glCopyTextureCHROMIUMProc>(
         GetGLProcAddress("glCopyTextureCHROMIUM"));
   }
 
-  debug_fn.glCoverageModulationNVFn = 0;
   if (ext.b_GL_NV_framebuffer_mixed_samples) {
     fn.glCoverageModulationNVFn = reinterpret_cast<glCoverageModulationNVProc>(
         GetGLProcAddress("glCoverageModulationNV"));
   }
 
-  debug_fn.glCoverFillPathInstancedNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glCoverFillPathInstancedNVFn =
         reinterpret_cast<glCoverFillPathInstancedNVProc>(
             GetGLProcAddress("glCoverFillPathInstancedNV"));
   }
 
-  debug_fn.glCoverFillPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glCoverFillPathNVFn = reinterpret_cast<glCoverFillPathNVProc>(
         GetGLProcAddress("glCoverFillPathNV"));
   }
 
-  debug_fn.glCoverStrokePathInstancedNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glCoverStrokePathInstancedNVFn =
         reinterpret_cast<glCoverStrokePathInstancedNVProc>(
             GetGLProcAddress("glCoverStrokePathInstancedNV"));
   }
 
-  debug_fn.glCoverStrokePathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glCoverStrokePathNVFn = reinterpret_cast<glCoverStrokePathNVProc>(
         GetGLProcAddress("glCoverStrokePathNV"));
   }
 
-  debug_fn.glDebugMessageCallbackFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glDebugMessageCallbackFn = reinterpret_cast<glDebugMessageCallbackProc>(
         GetGLProcAddress("glDebugMessageCallback"));
@@ -975,7 +933,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glDebugMessageCallbackKHR"));
   }
 
-  debug_fn.glDebugMessageControlFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glDebugMessageControlFn = reinterpret_cast<glDebugMessageControlProc>(
         GetGLProcAddress("glDebugMessageControl"));
@@ -984,7 +941,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glDebugMessageControlKHR"));
   }
 
-  debug_fn.glDebugMessageInsertFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glDebugMessageInsertFn = reinterpret_cast<glDebugMessageInsertProc>(
         GetGLProcAddress("glDebugMessageInsert"));
@@ -993,19 +949,16 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glDebugMessageInsertKHR"));
   }
 
-  debug_fn.glDeleteFencesAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glDeleteFencesAPPLEFn = reinterpret_cast<glDeleteFencesAPPLEProc>(
         GetGLProcAddress("glDeleteFencesAPPLE"));
   }
 
-  debug_fn.glDeleteFencesNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glDeleteFencesNVFn = reinterpret_cast<glDeleteFencesNVProc>(
         GetGLProcAddress("glDeleteFencesNV"));
   }
 
-  debug_fn.glDeleteFramebuffersEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glDeleteFramebuffersEXTFn =
         reinterpret_cast<glDeleteFramebuffersEXTProc>(
@@ -1016,13 +969,11 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glDeleteFramebuffersEXT"));
   }
 
-  debug_fn.glDeletePathsNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glDeletePathsNVFn = reinterpret_cast<glDeletePathsNVProc>(
         GetGLProcAddress("glDeletePathsNV"));
   }
 
-  debug_fn.glDeleteQueriesFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
         GetGLProcAddress("glDeleteQueries"));
@@ -1035,7 +986,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glDeleteQueriesEXT"));
   }
 
-  debug_fn.glDeleteRenderbuffersEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glDeleteRenderbuffersEXTFn =
         reinterpret_cast<glDeleteRenderbuffersEXTProc>(
@@ -1046,21 +996,18 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glDeleteRenderbuffersEXT"));
   }
 
-  debug_fn.glDeleteSamplersFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glDeleteSamplersFn = reinterpret_cast<glDeleteSamplersProc>(
         GetGLProcAddress("glDeleteSamplers"));
   }
 
-  debug_fn.glDeleteSyncFn = 0;
   if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sync) {
     fn.glDeleteSyncFn =
         reinterpret_cast<glDeleteSyncProc>(GetGLProcAddress("glDeleteSync"));
   }
 
-  debug_fn.glDeleteTransformFeedbacksFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
       ext.b_GL_ARB_transform_feedback2) {
     fn.glDeleteTransformFeedbacksFn =
@@ -1068,7 +1015,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glDeleteTransformFeedbacks"));
   }
 
-  debug_fn.glDeleteVertexArraysOESFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_vertex_array_object) {
     fn.glDeleteVertexArraysOESFn =
@@ -1084,20 +1030,17 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glDeleteVertexArraysAPPLE"));
   }
 
-  debug_fn.glDepthRangefFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
     fn.glDepthRangefFn =
         reinterpret_cast<glDepthRangefProc>(GetGLProcAddress("glDepthRangef"));
   }
 
-  debug_fn.glDiscardFramebufferEXTFn = 0;
   if (ext.b_GL_EXT_discard_framebuffer) {
     fn.glDiscardFramebufferEXTFn =
         reinterpret_cast<glDiscardFramebufferEXTProc>(
             GetGLProcAddress("glDiscardFramebufferEXT"));
   }
 
-  debug_fn.glDrawArraysInstancedANGLEFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glDrawArraysInstancedANGLEFn =
         reinterpret_cast<glDrawArraysInstancedANGLEProc>(
@@ -1112,13 +1055,11 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glDrawArraysInstancedANGLE"));
   }
 
-  debug_fn.glDrawBufferFn = 0;
   if (!ver->is_es) {
     fn.glDrawBufferFn =
         reinterpret_cast<glDrawBufferProc>(GetGLProcAddress("glDrawBuffer"));
   }
 
-  debug_fn.glDrawBuffersARBFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glDrawBuffersARBFn = reinterpret_cast<glDrawBuffersARBProc>(
         GetGLProcAddress("glDrawBuffers"));
@@ -1130,7 +1071,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glDrawBuffersEXT"));
   }
 
-  debug_fn.glDrawElementsInstancedANGLEFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glDrawElementsInstancedANGLEFn =
         reinterpret_cast<glDrawElementsInstancedANGLEProc>(
@@ -1145,27 +1085,23 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glDrawElementsInstancedANGLE"));
   }
 
-  debug_fn.glDrawRangeElementsFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glDrawRangeElementsFn = reinterpret_cast<glDrawRangeElementsProc>(
         GetGLProcAddress("glDrawRangeElements"));
   }
 
-  debug_fn.glEGLImageTargetRenderbufferStorageOESFn = 0;
   if (ext.b_GL_OES_EGL_image) {
     fn.glEGLImageTargetRenderbufferStorageOESFn =
         reinterpret_cast<glEGLImageTargetRenderbufferStorageOESProc>(
             GetGLProcAddress("glEGLImageTargetRenderbufferStorageOES"));
   }
 
-  debug_fn.glEGLImageTargetTexture2DOESFn = 0;
   if (ext.b_GL_OES_EGL_image) {
     fn.glEGLImageTargetTexture2DOESFn =
         reinterpret_cast<glEGLImageTargetTexture2DOESProc>(
             GetGLProcAddress("glEGLImageTargetTexture2DOES"));
   }
 
-  debug_fn.glEndQueryFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glEndQueryFn =
         reinterpret_cast<glEndQueryProc>(GetGLProcAddress("glEndQuery"));
@@ -1178,7 +1114,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         reinterpret_cast<glEndQueryProc>(GetGLProcAddress("glEndQueryEXT"));
   }
 
-  debug_fn.glEndTransformFeedbackFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glEndTransformFeedbackFn = reinterpret_cast<glEndTransformFeedbackProc>(
         GetGLProcAddress("glEndTransformFeedback"));
@@ -1187,33 +1122,28 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glEndTransformFeedbackEXT"));
   }
 
-  debug_fn.glFenceSyncFn = 0;
   if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sync) {
     fn.glFenceSyncFn =
         reinterpret_cast<glFenceSyncProc>(GetGLProcAddress("glFenceSync"));
   }
 
-  debug_fn.glFinishFenceAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glFinishFenceAPPLEFn = reinterpret_cast<glFinishFenceAPPLEProc>(
         GetGLProcAddress("glFinishFenceAPPLE"));
   }
 
-  debug_fn.glFinishFenceNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glFinishFenceNVFn = reinterpret_cast<glFinishFenceNVProc>(
         GetGLProcAddress("glFinishFenceNV"));
   }
 
-  debug_fn.glFlushMappedBufferRangeFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glFlushMappedBufferRangeFn =
         reinterpret_cast<glFlushMappedBufferRangeProc>(
             GetGLProcAddress("glFlushMappedBufferRange"));
   }
 
-  debug_fn.glFramebufferRenderbufferEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glFramebufferRenderbufferEXTFn =
         reinterpret_cast<glFramebufferRenderbufferEXTProc>(
@@ -1224,7 +1154,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glFramebufferRenderbufferEXT"));
   }
 
-  debug_fn.glFramebufferTexture2DEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glFramebufferTexture2DEXTFn =
         reinterpret_cast<glFramebufferTexture2DEXTProc>(
@@ -1235,28 +1164,24 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glFramebufferTexture2DEXT"));
   }
 
-  debug_fn.glFramebufferTexture2DMultisampleEXTFn = 0;
   if (ext.b_GL_EXT_multisampled_render_to_texture) {
     fn.glFramebufferTexture2DMultisampleEXTFn =
         reinterpret_cast<glFramebufferTexture2DMultisampleEXTProc>(
             GetGLProcAddress("glFramebufferTexture2DMultisampleEXT"));
   }
 
-  debug_fn.glFramebufferTexture2DMultisampleIMGFn = 0;
   if (ext.b_GL_IMG_multisampled_render_to_texture) {
     fn.glFramebufferTexture2DMultisampleIMGFn =
         reinterpret_cast<glFramebufferTexture2DMultisampleIMGProc>(
             GetGLProcAddress("glFramebufferTexture2DMultisampleIMG"));
   }
 
-  debug_fn.glFramebufferTextureLayerFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glFramebufferTextureLayerFn =
         reinterpret_cast<glFramebufferTextureLayerProc>(
             GetGLProcAddress("glFramebufferTextureLayer"));
   }
 
-  debug_fn.glGenerateMipmapEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glGenerateMipmapEXTFn = reinterpret_cast<glGenerateMipmapEXTProc>(
         GetGLProcAddress("glGenerateMipmap"));
@@ -1265,19 +1190,16 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGenerateMipmapEXT"));
   }
 
-  debug_fn.glGenFencesAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glGenFencesAPPLEFn = reinterpret_cast<glGenFencesAPPLEProc>(
         GetGLProcAddress("glGenFencesAPPLE"));
   }
 
-  debug_fn.glGenFencesNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glGenFencesNVFn =
         reinterpret_cast<glGenFencesNVProc>(GetGLProcAddress("glGenFencesNV"));
   }
 
-  debug_fn.glGenFramebuffersEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glGenFramebuffersEXTFn = reinterpret_cast<glGenFramebuffersEXTProc>(
         GetGLProcAddress("glGenFramebuffers"));
@@ -1286,13 +1208,11 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGenFramebuffersEXT"));
   }
 
-  debug_fn.glGenPathsNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glGenPathsNVFn =
         reinterpret_cast<glGenPathsNVProc>(GetGLProcAddress("glGenPathsNV"));
   }
 
-  debug_fn.glGenQueriesFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGenQueriesFn =
         reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueries"));
@@ -1305,7 +1225,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueriesEXT"));
   }
 
-  debug_fn.glGenRenderbuffersEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glGenRenderbuffersEXTFn = reinterpret_cast<glGenRenderbuffersEXTProc>(
         GetGLProcAddress("glGenRenderbuffers"));
@@ -1314,14 +1233,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGenRenderbuffersEXT"));
   }
 
-  debug_fn.glGenSamplersFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glGenSamplersFn =
         reinterpret_cast<glGenSamplersProc>(GetGLProcAddress("glGenSamplers"));
   }
 
-  debug_fn.glGenTransformFeedbacksFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
       ext.b_GL_ARB_transform_feedback2) {
     fn.glGenTransformFeedbacksFn =
@@ -1329,7 +1246,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGenTransformFeedbacks"));
   }
 
-  debug_fn.glGenVertexArraysOESFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_vertex_array_object) {
     fn.glGenVertexArraysOESFn = reinterpret_cast<glGenVertexArraysOESProc>(
@@ -1342,69 +1258,59 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGenVertexArraysAPPLE"));
   }
 
-  debug_fn.glGetActiveUniformBlockivFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glGetActiveUniformBlockivFn =
         reinterpret_cast<glGetActiveUniformBlockivProc>(
             GetGLProcAddress("glGetActiveUniformBlockiv"));
   }
 
-  debug_fn.glGetActiveUniformBlockivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetActiveUniformBlockivRobustANGLEFn =
         reinterpret_cast<glGetActiveUniformBlockivRobustANGLEProc>(
             GetGLProcAddress("glGetActiveUniformBlockivRobustANGLE"));
   }
 
-  debug_fn.glGetActiveUniformBlockNameFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glGetActiveUniformBlockNameFn =
         reinterpret_cast<glGetActiveUniformBlockNameProc>(
             GetGLProcAddress("glGetActiveUniformBlockName"));
   }
 
-  debug_fn.glGetActiveUniformsivFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glGetActiveUniformsivFn = reinterpret_cast<glGetActiveUniformsivProc>(
         GetGLProcAddress("glGetActiveUniformsiv"));
   }
 
-  debug_fn.glGetBooleani_vRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetBooleani_vRobustANGLEFn =
         reinterpret_cast<glGetBooleani_vRobustANGLEProc>(
             GetGLProcAddress("glGetBooleani_vRobustANGLE"));
   }
 
-  debug_fn.glGetBooleanvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetBooleanvRobustANGLEFn =
         reinterpret_cast<glGetBooleanvRobustANGLEProc>(
             GetGLProcAddress("glGetBooleanvRobustANGLE"));
   }
 
-  debug_fn.glGetBufferParameteri64vRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetBufferParameteri64vRobustANGLEFn =
         reinterpret_cast<glGetBufferParameteri64vRobustANGLEProc>(
             GetGLProcAddress("glGetBufferParameteri64vRobustANGLE"));
   }
 
-  debug_fn.glGetBufferParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetBufferParameterivRobustANGLEFn =
         reinterpret_cast<glGetBufferParameterivRobustANGLEProc>(
             GetGLProcAddress("glGetBufferParameterivRobustANGLE"));
   }
 
-  debug_fn.glGetBufferPointervRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetBufferPointervRobustANGLEFn =
         reinterpret_cast<glGetBufferPointervRobustANGLEProc>(
             GetGLProcAddress("glGetBufferPointervRobustANGLE"));
   }
 
-  debug_fn.glGetDebugMessageLogFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glGetDebugMessageLogFn = reinterpret_cast<glGetDebugMessageLogProc>(
         GetGLProcAddress("glGetDebugMessageLog"));
@@ -1413,19 +1319,16 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetDebugMessageLogKHR"));
   }
 
-  debug_fn.glGetFenceivNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glGetFenceivNVFn = reinterpret_cast<glGetFenceivNVProc>(
         GetGLProcAddress("glGetFenceivNV"));
   }
 
-  debug_fn.glGetFloatvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetFloatvRobustANGLEFn = reinterpret_cast<glGetFloatvRobustANGLEProc>(
         GetGLProcAddress("glGetFloatvRobustANGLE"));
   }
 
-  debug_fn.glGetFragDataIndexFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_blend_func_extended) {
     fn.glGetFragDataIndexFn = reinterpret_cast<glGetFragDataIndexProc>(
         GetGLProcAddress("glGetFragDataIndex"));
@@ -1434,13 +1337,11 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetFragDataIndexEXT"));
   }
 
-  debug_fn.glGetFragDataLocationFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetFragDataLocationFn = reinterpret_cast<glGetFragDataLocationProc>(
         GetGLProcAddress("glGetFragDataLocation"));
   }
 
-  debug_fn.glGetFramebufferAttachmentParameterivEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glGetFramebufferAttachmentParameterivEXTFn =
         reinterpret_cast<glGetFramebufferAttachmentParameterivEXTProc>(
@@ -1451,7 +1352,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGetFramebufferAttachmentParameterivEXT"));
   }
 
-  debug_fn.glGetFramebufferAttachmentParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetFramebufferAttachmentParameterivRobustANGLEFn =
         reinterpret_cast<glGetFramebufferAttachmentParameterivRobustANGLEProc>(
@@ -1459,14 +1359,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
                 "glGetFramebufferAttachmentParameterivRobustANGLE"));
   }
 
-  debug_fn.glGetFramebufferParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetFramebufferParameterivRobustANGLEFn =
         reinterpret_cast<glGetFramebufferParameterivRobustANGLEProc>(
             GetGLProcAddress("glGetFramebufferParameterivRobustANGLE"));
   }
 
-  debug_fn.glGetGraphicsResetStatusARBFn = 0;
   if (ver->IsAtLeastGL(4u, 5u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glGetGraphicsResetStatusARBFn =
         reinterpret_cast<glGetGraphicsResetStatusARBProc>(
@@ -1485,94 +1383,80 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGetGraphicsResetStatusEXT"));
   }
 
-  debug_fn.glGetInteger64i_vFn = 0;
   if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetInteger64i_vFn = reinterpret_cast<glGetInteger64i_vProc>(
         GetGLProcAddress("glGetInteger64i_v"));
   }
 
-  debug_fn.glGetInteger64i_vRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetInteger64i_vRobustANGLEFn =
         reinterpret_cast<glGetInteger64i_vRobustANGLEProc>(
             GetGLProcAddress("glGetInteger64i_vRobustANGLE"));
   }
 
-  debug_fn.glGetInteger64vFn = 0;
   if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetInteger64vFn = reinterpret_cast<glGetInteger64vProc>(
         GetGLProcAddress("glGetInteger64v"));
   }
 
-  debug_fn.glGetInteger64vRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetInteger64vRobustANGLEFn =
         reinterpret_cast<glGetInteger64vRobustANGLEProc>(
             GetGLProcAddress("glGetInteger64vRobustANGLE"));
   }
 
-  debug_fn.glGetIntegeri_vFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetIntegeri_vFn = reinterpret_cast<glGetIntegeri_vProc>(
         GetGLProcAddress("glGetIntegeri_v"));
   }
 
-  debug_fn.glGetIntegeri_vRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetIntegeri_vRobustANGLEFn =
         reinterpret_cast<glGetIntegeri_vRobustANGLEProc>(
             GetGLProcAddress("glGetIntegeri_vRobustANGLE"));
   }
 
-  debug_fn.glGetIntegervRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetIntegervRobustANGLEFn =
         reinterpret_cast<glGetIntegervRobustANGLEProc>(
             GetGLProcAddress("glGetIntegervRobustANGLE"));
   }
 
-  debug_fn.glGetInternalformativFn = 0;
   if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetInternalformativFn = reinterpret_cast<glGetInternalformativProc>(
         GetGLProcAddress("glGetInternalformativ"));
   }
 
-  debug_fn.glGetInternalformativRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetInternalformativRobustANGLEFn =
         reinterpret_cast<glGetInternalformativRobustANGLEProc>(
             GetGLProcAddress("glGetInternalformativRobustANGLE"));
   }
 
-  debug_fn.glGetMultisamplefvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetMultisamplefvRobustANGLEFn =
         reinterpret_cast<glGetMultisamplefvRobustANGLEProc>(
             GetGLProcAddress("glGetMultisamplefvRobustANGLE"));
   }
 
-  debug_fn.glGetnUniformfvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetnUniformfvRobustANGLEFn =
         reinterpret_cast<glGetnUniformfvRobustANGLEProc>(
             GetGLProcAddress("glGetnUniformfvRobustANGLE"));
   }
 
-  debug_fn.glGetnUniformivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetnUniformivRobustANGLEFn =
         reinterpret_cast<glGetnUniformivRobustANGLEProc>(
             GetGLProcAddress("glGetnUniformivRobustANGLE"));
   }
 
-  debug_fn.glGetnUniformuivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetnUniformuivRobustANGLEFn =
         reinterpret_cast<glGetnUniformuivRobustANGLEProc>(
             GetGLProcAddress("glGetnUniformuivRobustANGLE"));
   }
 
-  debug_fn.glGetObjectLabelFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glGetObjectLabelFn = reinterpret_cast<glGetObjectLabelProc>(
         GetGLProcAddress("glGetObjectLabel"));
@@ -1581,7 +1465,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetObjectLabelKHR"));
   }
 
-  debug_fn.glGetObjectPtrLabelFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glGetObjectPtrLabelFn = reinterpret_cast<glGetObjectPtrLabelProc>(
         GetGLProcAddress("glGetObjectPtrLabel"));
@@ -1590,7 +1473,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetObjectPtrLabelKHR"));
   }
 
-  debug_fn.glGetPointervFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glGetPointervFn =
         reinterpret_cast<glGetPointervProc>(GetGLProcAddress("glGetPointerv"));
@@ -1599,14 +1481,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetPointervKHR"));
   }
 
-  debug_fn.glGetPointervRobustANGLERobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetPointervRobustANGLERobustANGLEFn =
         reinterpret_cast<glGetPointervRobustANGLERobustANGLEProc>(
             GetGLProcAddress("glGetPointervRobustANGLERobustANGLE"));
   }
 
-  debug_fn.glGetProgramBinaryFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_get_program_binary) {
     fn.glGetProgramBinaryFn = reinterpret_cast<glGetProgramBinaryProc>(
@@ -1616,7 +1496,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetProgramBinaryOES"));
   }
 
-  debug_fn.glGetProgramInterfaceivFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 1u) ||
       ext.b_GL_ARB_program_interface_query) {
     fn.glGetProgramInterfaceivFn =
@@ -1624,35 +1503,30 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGetProgramInterfaceiv"));
   }
 
-  debug_fn.glGetProgramInterfaceivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetProgramInterfaceivRobustANGLEFn =
         reinterpret_cast<glGetProgramInterfaceivRobustANGLEProc>(
             GetGLProcAddress("glGetProgramInterfaceivRobustANGLE"));
   }
 
-  debug_fn.glGetProgramivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetProgramivRobustANGLEFn =
         reinterpret_cast<glGetProgramivRobustANGLEProc>(
             GetGLProcAddress("glGetProgramivRobustANGLE"));
   }
 
-  debug_fn.glGetProgramResourceivFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 1u) ||
       ext.b_GL_ARB_program_interface_query) {
     fn.glGetProgramResourceivFn = reinterpret_cast<glGetProgramResourceivProc>(
         GetGLProcAddress("glGetProgramResourceiv"));
   }
 
-  debug_fn.glGetProgramResourceLocationFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 1u)) {
     fn.glGetProgramResourceLocationFn =
         reinterpret_cast<glGetProgramResourceLocationProc>(
             GetGLProcAddress("glGetProgramResourceLocation"));
   }
 
-  debug_fn.glGetProgramResourceNameFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 1u) ||
       ext.b_GL_ARB_program_interface_query) {
     fn.glGetProgramResourceNameFn =
@@ -1660,7 +1534,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGetProgramResourceName"));
   }
 
-  debug_fn.glGetQueryivFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetQueryivFn =
         reinterpret_cast<glGetQueryivProc>(GetGLProcAddress("glGetQueryiv"));
@@ -1673,14 +1546,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         reinterpret_cast<glGetQueryivProc>(GetGLProcAddress("glGetQueryivEXT"));
   }
 
-  debug_fn.glGetQueryivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetQueryivRobustANGLEFn =
         reinterpret_cast<glGetQueryivRobustANGLEProc>(
             GetGLProcAddress("glGetQueryivRobustANGLE"));
   }
 
-  debug_fn.glGetQueryObjecti64vFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_timer_query) {
     fn.glGetQueryObjecti64vFn = reinterpret_cast<glGetQueryObjecti64vProc>(
         GetGLProcAddress("glGetQueryObjecti64v"));
@@ -1689,14 +1560,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetQueryObjecti64vEXT"));
   }
 
-  debug_fn.glGetQueryObjecti64vRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetQueryObjecti64vRobustANGLEFn =
         reinterpret_cast<glGetQueryObjecti64vRobustANGLEProc>(
             GetGLProcAddress("glGetQueryObjecti64vRobustANGLE"));
   }
 
-  debug_fn.glGetQueryObjectivFn = 0;
   if (!ver->is_es) {
     fn.glGetQueryObjectivFn = reinterpret_cast<glGetQueryObjectivProc>(
         GetGLProcAddress("glGetQueryObjectiv"));
@@ -1708,14 +1577,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetQueryObjectivEXT"));
   }
 
-  debug_fn.glGetQueryObjectivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetQueryObjectivRobustANGLEFn =
         reinterpret_cast<glGetQueryObjectivRobustANGLEProc>(
             GetGLProcAddress("glGetQueryObjectivRobustANGLE"));
   }
 
-  debug_fn.glGetQueryObjectui64vFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_timer_query) {
     fn.glGetQueryObjectui64vFn = reinterpret_cast<glGetQueryObjectui64vProc>(
         GetGLProcAddress("glGetQueryObjectui64v"));
@@ -1724,14 +1591,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetQueryObjectui64vEXT"));
   }
 
-  debug_fn.glGetQueryObjectui64vRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetQueryObjectui64vRobustANGLEFn =
         reinterpret_cast<glGetQueryObjectui64vRobustANGLEProc>(
             GetGLProcAddress("glGetQueryObjectui64vRobustANGLE"));
   }
 
-  debug_fn.glGetQueryObjectuivFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetQueryObjectuivFn = reinterpret_cast<glGetQueryObjectuivProc>(
         GetGLProcAddress("glGetQueryObjectuiv"));
@@ -1744,14 +1609,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glGetQueryObjectuivEXT"));
   }
 
-  debug_fn.glGetQueryObjectuivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetQueryObjectuivRobustANGLEFn =
         reinterpret_cast<glGetQueryObjectuivRobustANGLEProc>(
             GetGLProcAddress("glGetQueryObjectuivRobustANGLE"));
   }
 
-  debug_fn.glGetRenderbufferParameterivEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glGetRenderbufferParameterivEXTFn =
         reinterpret_cast<glGetRenderbufferParameterivEXTProc>(
@@ -1762,14 +1625,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGetRenderbufferParameterivEXT"));
   }
 
-  debug_fn.glGetRenderbufferParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetRenderbufferParameterivRobustANGLEFn =
         reinterpret_cast<glGetRenderbufferParameterivRobustANGLEProc>(
             GetGLProcAddress("glGetRenderbufferParameterivRobustANGLE"));
   }
 
-  debug_fn.glGetSamplerParameterfvFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glGetSamplerParameterfvFn =
@@ -1777,28 +1638,24 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGetSamplerParameterfv"));
   }
 
-  debug_fn.glGetSamplerParameterfvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetSamplerParameterfvRobustANGLEFn =
         reinterpret_cast<glGetSamplerParameterfvRobustANGLEProc>(
             GetGLProcAddress("glGetSamplerParameterfvRobustANGLE"));
   }
 
-  debug_fn.glGetSamplerParameterIivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetSamplerParameterIivRobustANGLEFn =
         reinterpret_cast<glGetSamplerParameterIivRobustANGLEProc>(
             GetGLProcAddress("glGetSamplerParameterIivRobustANGLE"));
   }
 
-  debug_fn.glGetSamplerParameterIuivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetSamplerParameterIuivRobustANGLEFn =
         reinterpret_cast<glGetSamplerParameterIuivRobustANGLEProc>(
             GetGLProcAddress("glGetSamplerParameterIuivRobustANGLE"));
   }
 
-  debug_fn.glGetSamplerParameterivFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glGetSamplerParameterivFn =
@@ -1806,91 +1663,78 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGetSamplerParameteriv"));
   }
 
-  debug_fn.glGetSamplerParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetSamplerParameterivRobustANGLEFn =
         reinterpret_cast<glGetSamplerParameterivRobustANGLEProc>(
             GetGLProcAddress("glGetSamplerParameterivRobustANGLE"));
   }
 
-  debug_fn.glGetShaderivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetShaderivRobustANGLEFn =
         reinterpret_cast<glGetShaderivRobustANGLEProc>(
             GetGLProcAddress("glGetShaderivRobustANGLE"));
   }
 
-  debug_fn.glGetShaderPrecisionFormatFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
     fn.glGetShaderPrecisionFormatFn =
         reinterpret_cast<glGetShaderPrecisionFormatProc>(
             GetGLProcAddress("glGetShaderPrecisionFormat"));
   }
 
-  debug_fn.glGetSyncivFn = 0;
   if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sync) {
     fn.glGetSyncivFn =
         reinterpret_cast<glGetSyncivProc>(GetGLProcAddress("glGetSynciv"));
   }
 
-  debug_fn.glGetTexLevelParameterfvFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 1u)) {
     fn.glGetTexLevelParameterfvFn =
         reinterpret_cast<glGetTexLevelParameterfvProc>(
             GetGLProcAddress("glGetTexLevelParameterfv"));
   }
 
-  debug_fn.glGetTexLevelParameterfvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetTexLevelParameterfvRobustANGLEFn =
         reinterpret_cast<glGetTexLevelParameterfvRobustANGLEProc>(
             GetGLProcAddress("glGetTexLevelParameterfvRobustANGLE"));
   }
 
-  debug_fn.glGetTexLevelParameterivFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 1u)) {
     fn.glGetTexLevelParameterivFn =
         reinterpret_cast<glGetTexLevelParameterivProc>(
             GetGLProcAddress("glGetTexLevelParameteriv"));
   }
 
-  debug_fn.glGetTexLevelParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetTexLevelParameterivRobustANGLEFn =
         reinterpret_cast<glGetTexLevelParameterivRobustANGLEProc>(
             GetGLProcAddress("glGetTexLevelParameterivRobustANGLE"));
   }
 
-  debug_fn.glGetTexParameterfvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetTexParameterfvRobustANGLEFn =
         reinterpret_cast<glGetTexParameterfvRobustANGLEProc>(
             GetGLProcAddress("glGetTexParameterfvRobustANGLE"));
   }
 
-  debug_fn.glGetTexParameterIivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetTexParameterIivRobustANGLEFn =
         reinterpret_cast<glGetTexParameterIivRobustANGLEProc>(
             GetGLProcAddress("glGetTexParameterIivRobustANGLE"));
   }
 
-  debug_fn.glGetTexParameterIuivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetTexParameterIuivRobustANGLEFn =
         reinterpret_cast<glGetTexParameterIuivRobustANGLEProc>(
             GetGLProcAddress("glGetTexParameterIuivRobustANGLE"));
   }
 
-  debug_fn.glGetTexParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetTexParameterivRobustANGLEFn =
         reinterpret_cast<glGetTexParameterivRobustANGLEProc>(
             GetGLProcAddress("glGetTexParameterivRobustANGLE"));
   }
 
-  debug_fn.glGetTransformFeedbackVaryingFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetTransformFeedbackVaryingFn =
         reinterpret_cast<glGetTransformFeedbackVaryingProc>(
@@ -1901,120 +1745,102 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glGetTransformFeedbackVaryingEXT"));
   }
 
-  debug_fn.glGetTranslatedShaderSourceANGLEFn = 0;
   if (ext.b_GL_ANGLE_translated_shader_source) {
     fn.glGetTranslatedShaderSourceANGLEFn =
         reinterpret_cast<glGetTranslatedShaderSourceANGLEProc>(
             GetGLProcAddress("glGetTranslatedShaderSourceANGLE"));
   }
 
-  debug_fn.glGetUniformBlockIndexFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glGetUniformBlockIndexFn = reinterpret_cast<glGetUniformBlockIndexProc>(
         GetGLProcAddress("glGetUniformBlockIndex"));
   }
 
-  debug_fn.glGetUniformfvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetUniformfvRobustANGLEFn =
         reinterpret_cast<glGetUniformfvRobustANGLEProc>(
             GetGLProcAddress("glGetUniformfvRobustANGLE"));
   }
 
-  debug_fn.glGetUniformIndicesFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glGetUniformIndicesFn = reinterpret_cast<glGetUniformIndicesProc>(
         GetGLProcAddress("glGetUniformIndices"));
   }
 
-  debug_fn.glGetUniformivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetUniformivRobustANGLEFn =
         reinterpret_cast<glGetUniformivRobustANGLEProc>(
             GetGLProcAddress("glGetUniformivRobustANGLE"));
   }
 
-  debug_fn.glGetUniformuivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGetUniformuivFn = reinterpret_cast<glGetUniformuivProc>(
         GetGLProcAddress("glGetUniformuiv"));
   }
 
-  debug_fn.glGetUniformuivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetUniformuivRobustANGLEFn =
         reinterpret_cast<glGetUniformuivRobustANGLEProc>(
             GetGLProcAddress("glGetUniformuivRobustANGLE"));
   }
 
-  debug_fn.glGetVertexAttribfvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetVertexAttribfvRobustANGLEFn =
         reinterpret_cast<glGetVertexAttribfvRobustANGLEProc>(
             GetGLProcAddress("glGetVertexAttribfvRobustANGLE"));
   }
 
-  debug_fn.glGetVertexAttribIivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetVertexAttribIivRobustANGLEFn =
         reinterpret_cast<glGetVertexAttribIivRobustANGLEProc>(
             GetGLProcAddress("glGetVertexAttribIivRobustANGLE"));
   }
 
-  debug_fn.glGetVertexAttribIuivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetVertexAttribIuivRobustANGLEFn =
         reinterpret_cast<glGetVertexAttribIuivRobustANGLEProc>(
             GetGLProcAddress("glGetVertexAttribIuivRobustANGLE"));
   }
 
-  debug_fn.glGetVertexAttribivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetVertexAttribivRobustANGLEFn =
         reinterpret_cast<glGetVertexAttribivRobustANGLEProc>(
             GetGLProcAddress("glGetVertexAttribivRobustANGLE"));
   }
 
-  debug_fn.glGetVertexAttribPointervRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glGetVertexAttribPointervRobustANGLEFn =
         reinterpret_cast<glGetVertexAttribPointervRobustANGLEProc>(
             GetGLProcAddress("glGetVertexAttribPointervRobustANGLE"));
   }
 
-  debug_fn.glInsertEventMarkerEXTFn = 0;
   if (ext.b_GL_EXT_debug_marker) {
     fn.glInsertEventMarkerEXTFn = reinterpret_cast<glInsertEventMarkerEXTProc>(
         GetGLProcAddress("glInsertEventMarkerEXT"));
   }
 
-  debug_fn.glInvalidateFramebufferFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glInvalidateFramebufferFn =
         reinterpret_cast<glInvalidateFramebufferProc>(
             GetGLProcAddress("glInvalidateFramebuffer"));
   }
 
-  debug_fn.glInvalidateSubFramebufferFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glInvalidateSubFramebufferFn =
         reinterpret_cast<glInvalidateSubFramebufferProc>(
             GetGLProcAddress("glInvalidateSubFramebuffer"));
   }
 
-  debug_fn.glIsFenceAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glIsFenceAPPLEFn = reinterpret_cast<glIsFenceAPPLEProc>(
         GetGLProcAddress("glIsFenceAPPLE"));
   }
 
-  debug_fn.glIsFenceNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glIsFenceNVFn =
         reinterpret_cast<glIsFenceNVProc>(GetGLProcAddress("glIsFenceNV"));
   }
 
-  debug_fn.glIsFramebufferEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glIsFramebufferEXTFn = reinterpret_cast<glIsFramebufferEXTProc>(
         GetGLProcAddress("glIsFramebuffer"));
@@ -2023,13 +1849,11 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glIsFramebufferEXT"));
   }
 
-  debug_fn.glIsPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glIsPathNVFn =
         reinterpret_cast<glIsPathNVProc>(GetGLProcAddress("glIsPathNV"));
   }
 
-  debug_fn.glIsQueryFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glIsQueryFn =
         reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQuery"));
@@ -2042,7 +1866,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQueryEXT"));
   }
 
-  debug_fn.glIsRenderbufferEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glIsRenderbufferEXTFn = reinterpret_cast<glIsRenderbufferEXTProc>(
         GetGLProcAddress("glIsRenderbuffer"));
@@ -2051,28 +1874,24 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glIsRenderbufferEXT"));
   }
 
-  debug_fn.glIsSamplerFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glIsSamplerFn =
         reinterpret_cast<glIsSamplerProc>(GetGLProcAddress("glIsSampler"));
   }
 
-  debug_fn.glIsSyncFn = 0;
   if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sync) {
     fn.glIsSyncFn =
         reinterpret_cast<glIsSyncProc>(GetGLProcAddress("glIsSync"));
   }
 
-  debug_fn.glIsTransformFeedbackFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
       ext.b_GL_ARB_transform_feedback2) {
     fn.glIsTransformFeedbackFn = reinterpret_cast<glIsTransformFeedbackProc>(
         GetGLProcAddress("glIsTransformFeedback"));
   }
 
-  debug_fn.glIsVertexArrayOESFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_vertex_array_object) {
     fn.glIsVertexArrayOESFn = reinterpret_cast<glIsVertexArrayOESProc>(
@@ -2085,7 +1904,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glIsVertexArrayAPPLE"));
   }
 
-  debug_fn.glMapBufferFn = 0;
   if (!ver->is_es) {
     fn.glMapBufferFn =
         reinterpret_cast<glMapBufferProc>(GetGLProcAddress("glMapBuffer"));
@@ -2094,7 +1912,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         reinterpret_cast<glMapBufferProc>(GetGLProcAddress("glMapBufferOES"));
   }
 
-  debug_fn.glMapBufferRangeFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_map_buffer_range) {
     fn.glMapBufferRangeFn = reinterpret_cast<glMapBufferRangeProc>(
@@ -2104,20 +1921,17 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glMapBufferRangeEXT"));
   }
 
-  debug_fn.glMatrixLoadfEXTFn = 0;
   if (ext.b_GL_EXT_direct_state_access || ext.b_GL_NV_path_rendering) {
     fn.glMatrixLoadfEXTFn = reinterpret_cast<glMatrixLoadfEXTProc>(
         GetGLProcAddress("glMatrixLoadfEXT"));
   }
 
-  debug_fn.glMatrixLoadIdentityEXTFn = 0;
   if (ext.b_GL_EXT_direct_state_access || ext.b_GL_NV_path_rendering) {
     fn.glMatrixLoadIdentityEXTFn =
         reinterpret_cast<glMatrixLoadIdentityEXTProc>(
             GetGLProcAddress("glMatrixLoadIdentityEXT"));
   }
 
-  debug_fn.glMemoryBarrierEXTFn = 0;
   if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 1u) ||
       ext.b_GL_ARB_shader_image_load_store) {
     fn.glMemoryBarrierEXTFn = reinterpret_cast<glMemoryBarrierEXTProc>(
@@ -2127,7 +1941,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glMemoryBarrierEXT"));
   }
 
-  debug_fn.glObjectLabelFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glObjectLabelFn =
         reinterpret_cast<glObjectLabelProc>(GetGLProcAddress("glObjectLabel"));
@@ -2136,7 +1949,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glObjectLabelKHR"));
   }
 
-  debug_fn.glObjectPtrLabelFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glObjectPtrLabelFn = reinterpret_cast<glObjectPtrLabelProc>(
         GetGLProcAddress("glObjectPtrLabel"));
@@ -2145,31 +1957,26 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glObjectPtrLabelKHR"));
   }
 
-  debug_fn.glPathCommandsNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glPathCommandsNVFn = reinterpret_cast<glPathCommandsNVProc>(
         GetGLProcAddress("glPathCommandsNV"));
   }
 
-  debug_fn.glPathParameterfNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glPathParameterfNVFn = reinterpret_cast<glPathParameterfNVProc>(
         GetGLProcAddress("glPathParameterfNV"));
   }
 
-  debug_fn.glPathParameteriNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glPathParameteriNVFn = reinterpret_cast<glPathParameteriNVProc>(
         GetGLProcAddress("glPathParameteriNV"));
   }
 
-  debug_fn.glPathStencilFuncNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glPathStencilFuncNVFn = reinterpret_cast<glPathStencilFuncNVProc>(
         GetGLProcAddress("glPathStencilFuncNV"));
   }
 
-  debug_fn.glPauseTransformFeedbackFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
       ext.b_GL_ARB_transform_feedback2) {
     fn.glPauseTransformFeedbackFn =
@@ -2177,13 +1984,11 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glPauseTransformFeedback"));
   }
 
-  debug_fn.glPointParameteriFn = 0;
   if (!ver->is_es) {
     fn.glPointParameteriFn = reinterpret_cast<glPointParameteriProc>(
         GetGLProcAddress("glPointParameteri"));
   }
 
-  debug_fn.glPopDebugGroupFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glPopDebugGroupFn = reinterpret_cast<glPopDebugGroupProc>(
         GetGLProcAddress("glPopDebugGroup"));
@@ -2192,20 +1997,17 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glPopDebugGroupKHR"));
   }
 
-  debug_fn.glPopGroupMarkerEXTFn = 0;
   if (ext.b_GL_EXT_debug_marker) {
     fn.glPopGroupMarkerEXTFn = reinterpret_cast<glPopGroupMarkerEXTProc>(
         GetGLProcAddress("glPopGroupMarkerEXT"));
   }
 
-  debug_fn.glPrimitiveRestartIndexFn = 0;
   if (ver->IsAtLeastGL(3u, 1u)) {
     fn.glPrimitiveRestartIndexFn =
         reinterpret_cast<glPrimitiveRestartIndexProc>(
             GetGLProcAddress("glPrimitiveRestartIndex"));
   }
 
-  debug_fn.glProgramBinaryFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_get_program_binary) {
     fn.glProgramBinaryFn = reinterpret_cast<glProgramBinaryProc>(
@@ -2215,21 +2017,18 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glProgramBinaryOES"));
   }
 
-  debug_fn.glProgramParameteriFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_get_program_binary) {
     fn.glProgramParameteriFn = reinterpret_cast<glProgramParameteriProc>(
         GetGLProcAddress("glProgramParameteri"));
   }
 
-  debug_fn.glProgramPathFragmentInputGenNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glProgramPathFragmentInputGenNVFn =
         reinterpret_cast<glProgramPathFragmentInputGenNVProc>(
             GetGLProcAddress("glProgramPathFragmentInputGenNV"));
   }
 
-  debug_fn.glPushDebugGroupFn = 0;
   if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
     fn.glPushDebugGroupFn = reinterpret_cast<glPushDebugGroupProc>(
         GetGLProcAddress("glPushDebugGroup"));
@@ -2238,13 +2037,11 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glPushDebugGroupKHR"));
   }
 
-  debug_fn.glPushGroupMarkerEXTFn = 0;
   if (ext.b_GL_EXT_debug_marker) {
     fn.glPushGroupMarkerEXTFn = reinterpret_cast<glPushGroupMarkerEXTProc>(
         GetGLProcAddress("glPushGroupMarkerEXT"));
   }
 
-  debug_fn.glQueryCounterFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_timer_query) {
     fn.glQueryCounterFn = reinterpret_cast<glQueryCounterProc>(
         GetGLProcAddress("glQueryCounter"));
@@ -2253,34 +2050,29 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glQueryCounterEXT"));
   }
 
-  debug_fn.glReadBufferFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glReadBufferFn =
         reinterpret_cast<glReadBufferProc>(GetGLProcAddress("glReadBuffer"));
   }
 
-  debug_fn.glReadnPixelsRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glReadnPixelsRobustANGLEFn =
         reinterpret_cast<glReadnPixelsRobustANGLEProc>(
             GetGLProcAddress("glReadnPixelsRobustANGLE"));
   }
 
-  debug_fn.glReadPixelsRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glReadPixelsRobustANGLEFn =
         reinterpret_cast<glReadPixelsRobustANGLEProc>(
             GetGLProcAddress("glReadPixelsRobustANGLE"));
   }
 
-  debug_fn.glReleaseShaderCompilerFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
     fn.glReleaseShaderCompilerFn =
         reinterpret_cast<glReleaseShaderCompilerProc>(
             GetGLProcAddress("glReleaseShaderCompiler"));
   }
 
-  debug_fn.glRenderbufferStorageEXTFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
     fn.glRenderbufferStorageEXTFn =
         reinterpret_cast<glRenderbufferStorageEXTProc>(
@@ -2291,21 +2083,18 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glRenderbufferStorageEXT"));
   }
 
-  debug_fn.glRenderbufferStorageMultisampleFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glRenderbufferStorageMultisampleFn =
         reinterpret_cast<glRenderbufferStorageMultisampleProc>(
             GetGLProcAddress("glRenderbufferStorageMultisample"));
   }
 
-  debug_fn.glRenderbufferStorageMultisampleANGLEFn = 0;
   if (ext.b_GL_ANGLE_framebuffer_multisample) {
     fn.glRenderbufferStorageMultisampleANGLEFn =
         reinterpret_cast<glRenderbufferStorageMultisampleANGLEProc>(
             GetGLProcAddress("glRenderbufferStorageMultisampleANGLE"));
   }
 
-  debug_fn.glRenderbufferStorageMultisampleEXTFn = 0;
   if (ext.b_GL_EXT_multisampled_render_to_texture ||
       ext.b_GL_EXT_framebuffer_multisample) {
     fn.glRenderbufferStorageMultisampleEXTFn =
@@ -2313,14 +2102,12 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glRenderbufferStorageMultisampleEXT"));
   }
 
-  debug_fn.glRenderbufferStorageMultisampleIMGFn = 0;
   if (ext.b_GL_IMG_multisampled_render_to_texture) {
     fn.glRenderbufferStorageMultisampleIMGFn =
         reinterpret_cast<glRenderbufferStorageMultisampleIMGProc>(
             GetGLProcAddress("glRenderbufferStorageMultisampleIMG"));
   }
 
-  debug_fn.glResumeTransformFeedbackFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
       ext.b_GL_ARB_transform_feedback2) {
     fn.glResumeTransformFeedbackFn =
@@ -2328,195 +2115,166 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glResumeTransformFeedback"));
   }
 
-  debug_fn.glSamplerParameterfFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glSamplerParameterfFn = reinterpret_cast<glSamplerParameterfProc>(
         GetGLProcAddress("glSamplerParameterf"));
   }
 
-  debug_fn.glSamplerParameterfvFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glSamplerParameterfvFn = reinterpret_cast<glSamplerParameterfvProc>(
         GetGLProcAddress("glSamplerParameterfv"));
   }
 
-  debug_fn.glSamplerParameterfvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glSamplerParameterfvRobustANGLEFn =
         reinterpret_cast<glSamplerParameterfvRobustANGLEProc>(
             GetGLProcAddress("glSamplerParameterfvRobustANGLE"));
   }
 
-  debug_fn.glSamplerParameteriFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glSamplerParameteriFn = reinterpret_cast<glSamplerParameteriProc>(
         GetGLProcAddress("glSamplerParameteri"));
   }
 
-  debug_fn.glSamplerParameterIivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glSamplerParameterIivRobustANGLEFn =
         reinterpret_cast<glSamplerParameterIivRobustANGLEProc>(
             GetGLProcAddress("glSamplerParameterIivRobustANGLE"));
   }
 
-  debug_fn.glSamplerParameterIuivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glSamplerParameterIuivRobustANGLEFn =
         reinterpret_cast<glSamplerParameterIuivRobustANGLEProc>(
             GetGLProcAddress("glSamplerParameterIuivRobustANGLE"));
   }
 
-  debug_fn.glSamplerParameterivFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sampler_objects) {
     fn.glSamplerParameterivFn = reinterpret_cast<glSamplerParameterivProc>(
         GetGLProcAddress("glSamplerParameteriv"));
   }
 
-  debug_fn.glSamplerParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glSamplerParameterivRobustANGLEFn =
         reinterpret_cast<glSamplerParameterivRobustANGLEProc>(
             GetGLProcAddress("glSamplerParameterivRobustANGLE"));
   }
 
-  debug_fn.glSetFenceAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glSetFenceAPPLEFn = reinterpret_cast<glSetFenceAPPLEProc>(
         GetGLProcAddress("glSetFenceAPPLE"));
   }
 
-  debug_fn.glSetFenceNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glSetFenceNVFn =
         reinterpret_cast<glSetFenceNVProc>(GetGLProcAddress("glSetFenceNV"));
   }
 
-  debug_fn.glShaderBinaryFn = 0;
   if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
     fn.glShaderBinaryFn = reinterpret_cast<glShaderBinaryProc>(
         GetGLProcAddress("glShaderBinary"));
   }
 
-  debug_fn.glStencilFillPathInstancedNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilFillPathInstancedNVFn =
         reinterpret_cast<glStencilFillPathInstancedNVProc>(
             GetGLProcAddress("glStencilFillPathInstancedNV"));
   }
 
-  debug_fn.glStencilFillPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilFillPathNVFn = reinterpret_cast<glStencilFillPathNVProc>(
         GetGLProcAddress("glStencilFillPathNV"));
   }
 
-  debug_fn.glStencilStrokePathInstancedNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilStrokePathInstancedNVFn =
         reinterpret_cast<glStencilStrokePathInstancedNVProc>(
             GetGLProcAddress("glStencilStrokePathInstancedNV"));
   }
 
-  debug_fn.glStencilStrokePathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilStrokePathNVFn = reinterpret_cast<glStencilStrokePathNVProc>(
         GetGLProcAddress("glStencilStrokePathNV"));
   }
 
-  debug_fn.glStencilThenCoverFillPathInstancedNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilThenCoverFillPathInstancedNVFn =
         reinterpret_cast<glStencilThenCoverFillPathInstancedNVProc>(
             GetGLProcAddress("glStencilThenCoverFillPathInstancedNV"));
   }
 
-  debug_fn.glStencilThenCoverFillPathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilThenCoverFillPathNVFn =
         reinterpret_cast<glStencilThenCoverFillPathNVProc>(
             GetGLProcAddress("glStencilThenCoverFillPathNV"));
   }
 
-  debug_fn.glStencilThenCoverStrokePathInstancedNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilThenCoverStrokePathInstancedNVFn =
         reinterpret_cast<glStencilThenCoverStrokePathInstancedNVProc>(
             GetGLProcAddress("glStencilThenCoverStrokePathInstancedNV"));
   }
 
-  debug_fn.glStencilThenCoverStrokePathNVFn = 0;
   if (ext.b_GL_NV_path_rendering) {
     fn.glStencilThenCoverStrokePathNVFn =
         reinterpret_cast<glStencilThenCoverStrokePathNVProc>(
             GetGLProcAddress("glStencilThenCoverStrokePathNV"));
   }
 
-  debug_fn.glTestFenceAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glTestFenceAPPLEFn = reinterpret_cast<glTestFenceAPPLEProc>(
         GetGLProcAddress("glTestFenceAPPLE"));
   }
 
-  debug_fn.glTestFenceNVFn = 0;
   if (ext.b_GL_NV_fence) {
     fn.glTestFenceNVFn =
         reinterpret_cast<glTestFenceNVProc>(GetGLProcAddress("glTestFenceNV"));
   }
 
-  debug_fn.glTexImage2DRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glTexImage2DRobustANGLEFn =
         reinterpret_cast<glTexImage2DRobustANGLEProc>(
             GetGLProcAddress("glTexImage2DRobustANGLE"));
   }
 
-  debug_fn.glTexImage3DFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glTexImage3DFn =
         reinterpret_cast<glTexImage3DProc>(GetGLProcAddress("glTexImage3D"));
   }
 
-  debug_fn.glTexImage3DRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glTexImage3DRobustANGLEFn =
         reinterpret_cast<glTexImage3DRobustANGLEProc>(
             GetGLProcAddress("glTexImage3DRobustANGLE"));
   }
 
-  debug_fn.glTexParameterfvRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glTexParameterfvRobustANGLEFn =
         reinterpret_cast<glTexParameterfvRobustANGLEProc>(
             GetGLProcAddress("glTexParameterfvRobustANGLE"));
   }
 
-  debug_fn.glTexParameterIivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glTexParameterIivRobustANGLEFn =
         reinterpret_cast<glTexParameterIivRobustANGLEProc>(
             GetGLProcAddress("glTexParameterIivRobustANGLE"));
   }
 
-  debug_fn.glTexParameterIuivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glTexParameterIuivRobustANGLEFn =
         reinterpret_cast<glTexParameterIuivRobustANGLEProc>(
             GetGLProcAddress("glTexParameterIuivRobustANGLE"));
   }
 
-  debug_fn.glTexParameterivRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glTexParameterivRobustANGLEFn =
         reinterpret_cast<glTexParameterivRobustANGLEProc>(
             GetGLProcAddress("glTexParameterivRobustANGLE"));
   }
 
-  debug_fn.glTexStorage2DEXTFn = 0;
   if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_texture_storage) {
     fn.glTexStorage2DEXTFn = reinterpret_cast<glTexStorage2DEXTProc>(
@@ -2526,34 +2284,29 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glTexStorage2DEXT"));
   }
 
-  debug_fn.glTexStorage3DFn = 0;
   if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_texture_storage) {
     fn.glTexStorage3DFn = reinterpret_cast<glTexStorage3DProc>(
         GetGLProcAddress("glTexStorage3D"));
   }
 
-  debug_fn.glTexSubImage2DRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glTexSubImage2DRobustANGLEFn =
         reinterpret_cast<glTexSubImage2DRobustANGLEProc>(
             GetGLProcAddress("glTexSubImage2DRobustANGLE"));
   }
 
-  debug_fn.glTexSubImage3DFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glTexSubImage3DFn = reinterpret_cast<glTexSubImage3DProc>(
         GetGLProcAddress("glTexSubImage3D"));
   }
 
-  debug_fn.glTexSubImage3DRobustANGLEFn = 0;
   if (ext.b_GL_ANGLE_robust_client_memory) {
     fn.glTexSubImage3DRobustANGLEFn =
         reinterpret_cast<glTexSubImage3DRobustANGLEProc>(
             GetGLProcAddress("glTexSubImage3DRobustANGLE"));
   }
 
-  debug_fn.glTransformFeedbackVaryingsFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glTransformFeedbackVaryingsFn =
         reinterpret_cast<glTransformFeedbackVaryingsProc>(
@@ -2564,97 +2317,81 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glTransformFeedbackVaryingsEXT"));
   }
 
-  debug_fn.glUniform1uiFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniform1uiFn =
         reinterpret_cast<glUniform1uiProc>(GetGLProcAddress("glUniform1ui"));
   }
 
-  debug_fn.glUniform1uivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniform1uivFn =
         reinterpret_cast<glUniform1uivProc>(GetGLProcAddress("glUniform1uiv"));
   }
 
-  debug_fn.glUniform2uiFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniform2uiFn =
         reinterpret_cast<glUniform2uiProc>(GetGLProcAddress("glUniform2ui"));
   }
 
-  debug_fn.glUniform2uivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniform2uivFn =
         reinterpret_cast<glUniform2uivProc>(GetGLProcAddress("glUniform2uiv"));
   }
 
-  debug_fn.glUniform3uiFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniform3uiFn =
         reinterpret_cast<glUniform3uiProc>(GetGLProcAddress("glUniform3ui"));
   }
 
-  debug_fn.glUniform3uivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniform3uivFn =
         reinterpret_cast<glUniform3uivProc>(GetGLProcAddress("glUniform3uiv"));
   }
 
-  debug_fn.glUniform4uiFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniform4uiFn =
         reinterpret_cast<glUniform4uiProc>(GetGLProcAddress("glUniform4ui"));
   }
 
-  debug_fn.glUniform4uivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniform4uivFn =
         reinterpret_cast<glUniform4uivProc>(GetGLProcAddress("glUniform4uiv"));
   }
 
-  debug_fn.glUniformBlockBindingFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
     fn.glUniformBlockBindingFn = reinterpret_cast<glUniformBlockBindingProc>(
         GetGLProcAddress("glUniformBlockBinding"));
   }
 
-  debug_fn.glUniformMatrix2x3fvFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniformMatrix2x3fvFn = reinterpret_cast<glUniformMatrix2x3fvProc>(
         GetGLProcAddress("glUniformMatrix2x3fv"));
   }
 
-  debug_fn.glUniformMatrix2x4fvFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniformMatrix2x4fvFn = reinterpret_cast<glUniformMatrix2x4fvProc>(
         GetGLProcAddress("glUniformMatrix2x4fv"));
   }
 
-  debug_fn.glUniformMatrix3x2fvFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniformMatrix3x2fvFn = reinterpret_cast<glUniformMatrix3x2fvProc>(
         GetGLProcAddress("glUniformMatrix3x2fv"));
   }
 
-  debug_fn.glUniformMatrix3x4fvFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniformMatrix3x4fvFn = reinterpret_cast<glUniformMatrix3x4fvProc>(
         GetGLProcAddress("glUniformMatrix3x4fv"));
   }
 
-  debug_fn.glUniformMatrix4x2fvFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniformMatrix4x2fvFn = reinterpret_cast<glUniformMatrix4x2fvProc>(
         GetGLProcAddress("glUniformMatrix4x2fv"));
   }
 
-  debug_fn.glUniformMatrix4x3fvFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUniformMatrix4x3fvFn = reinterpret_cast<glUniformMatrix4x3fvProc>(
         GetGLProcAddress("glUniformMatrix4x3fv"));
   }
 
-  debug_fn.glUnmapBufferFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glUnmapBufferFn =
         reinterpret_cast<glUnmapBufferProc>(GetGLProcAddress("glUnmapBuffer"));
@@ -2663,7 +2400,6 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
         GetGLProcAddress("glUnmapBufferOES"));
   }
 
-  debug_fn.glVertexAttribDivisorANGLEFn = 0;
   if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glVertexAttribDivisorANGLEFn =
         reinterpret_cast<glVertexAttribDivisorANGLEProc>(
@@ -2678,6319 +2414,36 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
             GetGLProcAddress("glVertexAttribDivisorANGLE"));
   }
 
-  debug_fn.glVertexAttribI4iFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glVertexAttribI4iFn = reinterpret_cast<glVertexAttribI4iProc>(
         GetGLProcAddress("glVertexAttribI4i"));
   }
 
-  debug_fn.glVertexAttribI4ivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glVertexAttribI4ivFn = reinterpret_cast<glVertexAttribI4ivProc>(
         GetGLProcAddress("glVertexAttribI4iv"));
   }
 
-  debug_fn.glVertexAttribI4uiFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glVertexAttribI4uiFn = reinterpret_cast<glVertexAttribI4uiProc>(
         GetGLProcAddress("glVertexAttribI4ui"));
   }
 
-  debug_fn.glVertexAttribI4uivFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glVertexAttribI4uivFn = reinterpret_cast<glVertexAttribI4uivProc>(
         GetGLProcAddress("glVertexAttribI4uiv"));
   }
 
-  debug_fn.glVertexAttribIPointerFn = 0;
   if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glVertexAttribIPointerFn = reinterpret_cast<glVertexAttribIPointerProc>(
         GetGLProcAddress("glVertexAttribIPointer"));
   }
 
-  debug_fn.glWaitSyncFn = 0;
   if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
       ext.b_GL_ARB_sync) {
     fn.glWaitSyncFn =
         reinterpret_cast<glWaitSyncProc>(GetGLProcAddress("glWaitSync"));
   }
-
-  if (g_debugBindingsInitialized)
-    InitializeDebugBindings();
-}
-
-extern "C" {
-
-static void GL_BINDING_CALL Debug_glActiveTexture(GLenum texture) {
-  GL_SERVICE_LOG("glActiveTexture"
-                 << "(" << GLEnums::GetStringEnum(texture) << ")");
-  DCHECK(g_driver_gl.debug_fn.glActiveTextureFn != nullptr);
-  g_driver_gl.debug_fn.glActiveTextureFn(texture);
-}
-
-static void GL_BINDING_CALL Debug_glApplyFramebufferAttachmentCMAAINTEL(void) {
-  GL_SERVICE_LOG("glApplyFramebufferAttachmentCMAAINTEL"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glApplyFramebufferAttachmentCMAAINTELFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glApplyFramebufferAttachmentCMAAINTELFn();
-}
-
-static void GL_BINDING_CALL Debug_glAttachShader(GLuint program,
-                                                 GLuint shader) {
-  GL_SERVICE_LOG("glAttachShader"
-                 << "(" << program << ", " << shader << ")");
-  DCHECK(g_driver_gl.debug_fn.glAttachShaderFn != nullptr);
-  g_driver_gl.debug_fn.glAttachShaderFn(program, shader);
-}
-
-static void GL_BINDING_CALL Debug_glBeginQuery(GLenum target, GLuint id) {
-  GL_SERVICE_LOG("glBeginQuery"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
-  DCHECK(g_driver_gl.debug_fn.glBeginQueryFn != nullptr);
-  g_driver_gl.debug_fn.glBeginQueryFn(target, id);
-}
-
-static void GL_BINDING_CALL
-Debug_glBeginTransformFeedback(GLenum primitiveMode) {
-  GL_SERVICE_LOG("glBeginTransformFeedback"
-                 << "(" << GLEnums::GetStringEnum(primitiveMode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBeginTransformFeedbackFn != nullptr);
-  g_driver_gl.debug_fn.glBeginTransformFeedbackFn(primitiveMode);
-}
-
-static void GL_BINDING_CALL Debug_glBindAttribLocation(GLuint program,
-                                                       GLuint index,
-                                                       const char* name) {
-  GL_SERVICE_LOG("glBindAttribLocation"
-                 << "(" << program << ", " << index << ", " << name << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindAttribLocationFn != nullptr);
-  g_driver_gl.debug_fn.glBindAttribLocationFn(program, index, name);
-}
-
-static void GL_BINDING_CALL Debug_glBindBuffer(GLenum target, GLuint buffer) {
-  GL_SERVICE_LOG("glBindBuffer"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << buffer
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindBufferFn != nullptr);
-  g_driver_gl.debug_fn.glBindBufferFn(target, buffer);
-}
-
-static void GL_BINDING_CALL Debug_glBindBufferBase(GLenum target,
-                                                   GLuint index,
-                                                   GLuint buffer) {
-  GL_SERVICE_LOG("glBindBufferBase"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
-                 << ", " << buffer << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindBufferBaseFn != nullptr);
-  g_driver_gl.debug_fn.glBindBufferBaseFn(target, index, buffer);
-}
-
-static void GL_BINDING_CALL Debug_glBindBufferRange(GLenum target,
-                                                    GLuint index,
-                                                    GLuint buffer,
-                                                    GLintptr offset,
-                                                    GLsizeiptr size) {
-  GL_SERVICE_LOG("glBindBufferRange"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
-                 << ", " << buffer << ", " << offset << ", " << size << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindBufferRangeFn != nullptr);
-  g_driver_gl.debug_fn.glBindBufferRangeFn(target, index, buffer, offset, size);
-}
-
-static void GL_BINDING_CALL Debug_glBindFragDataLocation(GLuint program,
-                                                         GLuint colorNumber,
-                                                         const char* name) {
-  GL_SERVICE_LOG("glBindFragDataLocation"
-                 << "(" << program << ", " << colorNumber << ", " << name
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindFragDataLocationFn != nullptr);
-  g_driver_gl.debug_fn.glBindFragDataLocationFn(program, colorNumber, name);
-}
-
-static void GL_BINDING_CALL
-Debug_glBindFragDataLocationIndexed(GLuint program,
-                                    GLuint colorNumber,
-                                    GLuint index,
-                                    const char* name) {
-  GL_SERVICE_LOG("glBindFragDataLocationIndexed"
-                 << "(" << program << ", " << colorNumber << ", " << index
-                 << ", " << name << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindFragDataLocationIndexedFn != nullptr);
-  g_driver_gl.debug_fn.glBindFragDataLocationIndexedFn(program, colorNumber,
-                                                       index, name);
-}
-
-static void GL_BINDING_CALL Debug_glBindFramebufferEXT(GLenum target,
-                                                       GLuint framebuffer) {
-  GL_SERVICE_LOG("glBindFramebufferEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << framebuffer
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindFramebufferEXTFn != nullptr);
-  g_driver_gl.debug_fn.glBindFramebufferEXTFn(target, framebuffer);
-}
-
-static void GL_BINDING_CALL Debug_glBindImageTextureEXT(GLuint index,
-                                                        GLuint texture,
-                                                        GLint level,
-                                                        GLboolean layered,
-                                                        GLint layer,
-                                                        GLenum access,
-                                                        GLint format) {
-  GL_SERVICE_LOG("glBindImageTextureEXT"
-                 << "(" << index << ", " << texture << ", " << level << ", "
-                 << GLEnums::GetStringBool(layered) << ", " << layer << ", "
-                 << GLEnums::GetStringEnum(access) << ", " << format << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindImageTextureEXTFn != nullptr);
-  g_driver_gl.debug_fn.glBindImageTextureEXTFn(index, texture, level, layered,
-                                               layer, access, format);
-}
-
-static void GL_BINDING_CALL Debug_glBindRenderbufferEXT(GLenum target,
-                                                        GLuint renderbuffer) {
-  GL_SERVICE_LOG("glBindRenderbufferEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << renderbuffer << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindRenderbufferEXTFn != nullptr);
-  g_driver_gl.debug_fn.glBindRenderbufferEXTFn(target, renderbuffer);
-}
-
-static void GL_BINDING_CALL Debug_glBindSampler(GLuint unit, GLuint sampler) {
-  GL_SERVICE_LOG("glBindSampler"
-                 << "(" << unit << ", " << sampler << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindSamplerFn != nullptr);
-  g_driver_gl.debug_fn.glBindSamplerFn(unit, sampler);
-}
-
-static void GL_BINDING_CALL Debug_glBindTexture(GLenum target, GLuint texture) {
-  GL_SERVICE_LOG("glBindTexture"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << texture
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindTextureFn != nullptr);
-  g_driver_gl.debug_fn.glBindTextureFn(target, texture);
-}
-
-static void GL_BINDING_CALL Debug_glBindTransformFeedback(GLenum target,
-                                                          GLuint id) {
-  GL_SERVICE_LOG("glBindTransformFeedback"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindTransformFeedbackFn != nullptr);
-  g_driver_gl.debug_fn.glBindTransformFeedbackFn(target, id);
-}
-
-static void GL_BINDING_CALL
-Debug_glBindUniformLocationCHROMIUM(GLuint program,
-                                    GLint location,
-                                    const char* name) {
-  GL_SERVICE_LOG("glBindUniformLocationCHROMIUM"
-                 << "(" << program << ", " << location << ", " << name << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindUniformLocationCHROMIUMFn != nullptr);
-  g_driver_gl.debug_fn.glBindUniformLocationCHROMIUMFn(program, location, name);
-}
-
-static void GL_BINDING_CALL Debug_glBindVertexArrayOES(GLuint array) {
-  GL_SERVICE_LOG("glBindVertexArrayOES"
-                 << "(" << array << ")");
-  DCHECK(g_driver_gl.debug_fn.glBindVertexArrayOESFn != nullptr);
-  g_driver_gl.debug_fn.glBindVertexArrayOESFn(array);
-}
-
-static void GL_BINDING_CALL Debug_glBlendBarrierKHR(void) {
-  GL_SERVICE_LOG("glBlendBarrierKHR"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlendBarrierKHRFn != nullptr);
-  g_driver_gl.debug_fn.glBlendBarrierKHRFn();
-}
-
-static void GL_BINDING_CALL Debug_glBlendColor(GLclampf red,
-                                               GLclampf green,
-                                               GLclampf blue,
-                                               GLclampf alpha) {
-  GL_SERVICE_LOG("glBlendColor"
-                 << "(" << red << ", " << green << ", " << blue << ", " << alpha
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlendColorFn != nullptr);
-  g_driver_gl.debug_fn.glBlendColorFn(red, green, blue, alpha);
-}
-
-static void GL_BINDING_CALL Debug_glBlendEquation(GLenum mode) {
-  GL_SERVICE_LOG("glBlendEquation"
-                 << "(" << GLEnums::GetStringEnum(mode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlendEquationFn != nullptr);
-  g_driver_gl.debug_fn.glBlendEquationFn(mode);
-}
-
-static void GL_BINDING_CALL Debug_glBlendEquationSeparate(GLenum modeRGB,
-                                                          GLenum modeAlpha) {
-  GL_SERVICE_LOG("glBlendEquationSeparate"
-                 << "(" << GLEnums::GetStringEnum(modeRGB) << ", "
-                 << GLEnums::GetStringEnum(modeAlpha) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlendEquationSeparateFn != nullptr);
-  g_driver_gl.debug_fn.glBlendEquationSeparateFn(modeRGB, modeAlpha);
-}
-
-static void GL_BINDING_CALL Debug_glBlendFunc(GLenum sfactor, GLenum dfactor) {
-  GL_SERVICE_LOG("glBlendFunc"
-                 << "(" << GLEnums::GetStringEnum(sfactor) << ", "
-                 << GLEnums::GetStringEnum(dfactor) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlendFuncFn != nullptr);
-  g_driver_gl.debug_fn.glBlendFuncFn(sfactor, dfactor);
-}
-
-static void GL_BINDING_CALL Debug_glBlendFuncSeparate(GLenum srcRGB,
-                                                      GLenum dstRGB,
-                                                      GLenum srcAlpha,
-                                                      GLenum dstAlpha) {
-  GL_SERVICE_LOG("glBlendFuncSeparate"
-                 << "(" << GLEnums::GetStringEnum(srcRGB) << ", "
-                 << GLEnums::GetStringEnum(dstRGB) << ", "
-                 << GLEnums::GetStringEnum(srcAlpha) << ", "
-                 << GLEnums::GetStringEnum(dstAlpha) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlendFuncSeparateFn != nullptr);
-  g_driver_gl.debug_fn.glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha,
-                                             dstAlpha);
-}
-
-static void GL_BINDING_CALL Debug_glBlitFramebuffer(GLint srcX0,
-                                                    GLint srcY0,
-                                                    GLint srcX1,
-                                                    GLint srcY1,
-                                                    GLint dstX0,
-                                                    GLint dstY0,
-                                                    GLint dstX1,
-                                                    GLint dstY1,
-                                                    GLbitfield mask,
-                                                    GLenum filter) {
-  GL_SERVICE_LOG("glBlitFramebuffer"
-                 << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
-                 << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
-                 << ", " << dstY1 << ", " << mask << ", "
-                 << GLEnums::GetStringEnum(filter) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlitFramebufferFn != nullptr);
-  g_driver_gl.debug_fn.glBlitFramebufferFn(srcX0, srcY0, srcX1, srcY1, dstX0,
-                                           dstY0, dstX1, dstY1, mask, filter);
-}
-
-static void GL_BINDING_CALL Debug_glBlitFramebufferANGLE(GLint srcX0,
-                                                         GLint srcY0,
-                                                         GLint srcX1,
-                                                         GLint srcY1,
-                                                         GLint dstX0,
-                                                         GLint dstY0,
-                                                         GLint dstX1,
-                                                         GLint dstY1,
-                                                         GLbitfield mask,
-                                                         GLenum filter) {
-  GL_SERVICE_LOG("glBlitFramebufferANGLE"
-                 << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
-                 << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
-                 << ", " << dstY1 << ", " << mask << ", "
-                 << GLEnums::GetStringEnum(filter) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlitFramebufferANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glBlitFramebufferANGLEFn(
-      srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-static void GL_BINDING_CALL Debug_glBlitFramebufferEXT(GLint srcX0,
-                                                       GLint srcY0,
-                                                       GLint srcX1,
-                                                       GLint srcY1,
-                                                       GLint dstX0,
-                                                       GLint dstY0,
-                                                       GLint dstX1,
-                                                       GLint dstY1,
-                                                       GLbitfield mask,
-                                                       GLenum filter) {
-  GL_SERVICE_LOG("glBlitFramebufferEXT"
-                 << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
-                 << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
-                 << ", " << dstY1 << ", " << mask << ", "
-                 << GLEnums::GetStringEnum(filter) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBlitFramebufferEXTFn != nullptr);
-  g_driver_gl.debug_fn.glBlitFramebufferEXTFn(
-      srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-static void GL_BINDING_CALL Debug_glBufferData(GLenum target,
-                                               GLsizeiptr size,
-                                               const void* data,
-                                               GLenum usage) {
-  GL_SERVICE_LOG("glBufferData"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << size
-                 << ", " << static_cast<const void*>(data) << ", "
-                 << GLEnums::GetStringEnum(usage) << ")");
-  DCHECK(g_driver_gl.debug_fn.glBufferDataFn != nullptr);
-  g_driver_gl.debug_fn.glBufferDataFn(target, size, data, usage);
-}
-
-static void GL_BINDING_CALL Debug_glBufferSubData(GLenum target,
-                                                  GLintptr offset,
-                                                  GLsizeiptr size,
-                                                  const void* data) {
-  GL_SERVICE_LOG("glBufferSubData"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << offset
-                 << ", " << size << ", " << static_cast<const void*>(data)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glBufferSubDataFn != nullptr);
-  g_driver_gl.debug_fn.glBufferSubDataFn(target, offset, size, data);
-}
-
-static GLenum GL_BINDING_CALL Debug_glCheckFramebufferStatusEXT(GLenum target) {
-  GL_SERVICE_LOG("glCheckFramebufferStatusEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCheckFramebufferStatusEXTFn != nullptr);
-  GLenum result = g_driver_gl.debug_fn.glCheckFramebufferStatusEXTFn(target);
-
-  GL_SERVICE_LOG("GL_RESULT: " << GLEnums::GetStringEnum(result));
-
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glClear(GLbitfield mask) {
-  GL_SERVICE_LOG("glClear"
-                 << "(" << mask << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearFn != nullptr);
-  g_driver_gl.debug_fn.glClearFn(mask);
-}
-
-static void GL_BINDING_CALL Debug_glClearBufferfi(GLenum buffer,
-                                                  GLint drawbuffer,
-                                                  const GLfloat depth,
-                                                  GLint stencil) {
-  GL_SERVICE_LOG("glClearBufferfi"
-                 << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
-                 << ", " << depth << ", " << stencil << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearBufferfiFn != nullptr);
-  g_driver_gl.debug_fn.glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
-}
-
-static void GL_BINDING_CALL Debug_glClearBufferfv(GLenum buffer,
-                                                  GLint drawbuffer,
-                                                  const GLfloat* value) {
-  GL_SERVICE_LOG("glClearBufferfv"
-                 << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
-                 << ", " << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearBufferfvFn != nullptr);
-  g_driver_gl.debug_fn.glClearBufferfvFn(buffer, drawbuffer, value);
-}
-
-static void GL_BINDING_CALL Debug_glClearBufferiv(GLenum buffer,
-                                                  GLint drawbuffer,
-                                                  const GLint* value) {
-  GL_SERVICE_LOG("glClearBufferiv"
-                 << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
-                 << ", " << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearBufferivFn != nullptr);
-  g_driver_gl.debug_fn.glClearBufferivFn(buffer, drawbuffer, value);
-}
-
-static void GL_BINDING_CALL Debug_glClearBufferuiv(GLenum buffer,
-                                                   GLint drawbuffer,
-                                                   const GLuint* value) {
-  GL_SERVICE_LOG("glClearBufferuiv"
-                 << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
-                 << ", " << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearBufferuivFn != nullptr);
-  g_driver_gl.debug_fn.glClearBufferuivFn(buffer, drawbuffer, value);
-}
-
-static void GL_BINDING_CALL Debug_glClearColor(GLclampf red,
-                                               GLclampf green,
-                                               GLclampf blue,
-                                               GLclampf alpha) {
-  GL_SERVICE_LOG("glClearColor"
-                 << "(" << red << ", " << green << ", " << blue << ", " << alpha
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearColorFn != nullptr);
-  g_driver_gl.debug_fn.glClearColorFn(red, green, blue, alpha);
-}
-
-static void GL_BINDING_CALL Debug_glClearDepth(GLclampd depth) {
-  GL_SERVICE_LOG("glClearDepth"
-                 << "(" << depth << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearDepthFn != nullptr);
-  g_driver_gl.debug_fn.glClearDepthFn(depth);
-}
-
-static void GL_BINDING_CALL Debug_glClearDepthf(GLclampf depth) {
-  GL_SERVICE_LOG("glClearDepthf"
-                 << "(" << depth << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearDepthfFn != nullptr);
-  g_driver_gl.debug_fn.glClearDepthfFn(depth);
-}
-
-static void GL_BINDING_CALL Debug_glClearStencil(GLint s) {
-  GL_SERVICE_LOG("glClearStencil"
-                 << "(" << s << ")");
-  DCHECK(g_driver_gl.debug_fn.glClearStencilFn != nullptr);
-  g_driver_gl.debug_fn.glClearStencilFn(s);
-}
-
-static GLenum GL_BINDING_CALL Debug_glClientWaitSync(GLsync sync,
-                                                     GLbitfield flags,
-                                                     GLuint64 timeout) {
-  GL_SERVICE_LOG("glClientWaitSync"
-                 << "(" << sync << ", " << flags << ", " << timeout << ")");
-  DCHECK(g_driver_gl.debug_fn.glClientWaitSyncFn != nullptr);
-  GLenum result = g_driver_gl.debug_fn.glClientWaitSyncFn(sync, flags, timeout);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glColorMask(GLboolean red,
-                                              GLboolean green,
-                                              GLboolean blue,
-                                              GLboolean alpha) {
-  GL_SERVICE_LOG("glColorMask"
-                 << "(" << GLEnums::GetStringBool(red) << ", "
-                 << GLEnums::GetStringBool(green) << ", "
-                 << GLEnums::GetStringBool(blue) << ", "
-                 << GLEnums::GetStringBool(alpha) << ")");
-  DCHECK(g_driver_gl.debug_fn.glColorMaskFn != nullptr);
-  g_driver_gl.debug_fn.glColorMaskFn(red, green, blue, alpha);
-}
-
-static void GL_BINDING_CALL Debug_glCompileShader(GLuint shader) {
-  GL_SERVICE_LOG("glCompileShader"
-                 << "(" << shader << ")");
-  DCHECK(g_driver_gl.debug_fn.glCompileShaderFn != nullptr);
-  g_driver_gl.debug_fn.glCompileShaderFn(shader);
-}
-
-static void GL_BINDING_CALL
-Debug_glCompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId) {
-  GL_SERVICE_LOG("glCompressedCopyTextureCHROMIUM"
-                 << "(" << sourceId << ", " << destId << ")");
-  DCHECK(g_driver_gl.debug_fn.glCompressedCopyTextureCHROMIUMFn != nullptr);
-  g_driver_gl.debug_fn.glCompressedCopyTextureCHROMIUMFn(sourceId, destId);
-}
-
-static void GL_BINDING_CALL Debug_glCompressedTexImage2D(GLenum target,
-                                                         GLint level,
-                                                         GLenum internalformat,
-                                                         GLsizei width,
-                                                         GLsizei height,
-                                                         GLint border,
-                                                         GLsizei imageSize,
-                                                         const void* data) {
-  GL_SERVICE_LOG("glCompressedTexImage2D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
-                 << width << ", " << height << ", " << border << ", "
-                 << imageSize << ", " << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCompressedTexImage2DFn != nullptr);
-  g_driver_gl.debug_fn.glCompressedTexImage2DFn(
-      target, level, internalformat, width, height, border, imageSize, data);
-}
-
-static void GL_BINDING_CALL Debug_glCompressedTexImage3D(GLenum target,
-                                                         GLint level,
-                                                         GLenum internalformat,
-                                                         GLsizei width,
-                                                         GLsizei height,
-                                                         GLsizei depth,
-                                                         GLint border,
-                                                         GLsizei imageSize,
-                                                         const void* data) {
-  GL_SERVICE_LOG("glCompressedTexImage3D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
-                 << width << ", " << height << ", " << depth << ", " << border
-                 << ", " << imageSize << ", " << static_cast<const void*>(data)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glCompressedTexImage3DFn != nullptr);
-  g_driver_gl.debug_fn.glCompressedTexImage3DFn(target, level, internalformat,
-                                                width, height, depth, border,
-                                                imageSize, data);
-}
-
-static void GL_BINDING_CALL Debug_glCompressedTexSubImage2D(GLenum target,
-                                                            GLint level,
-                                                            GLint xoffset,
-                                                            GLint yoffset,
-                                                            GLsizei width,
-                                                            GLsizei height,
-                                                            GLenum format,
-                                                            GLsizei imageSize,
-                                                            const void* data) {
-  GL_SERVICE_LOG("glCompressedTexSubImage2D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << xoffset << ", " << yoffset << ", " << width << ", "
-                 << height << ", " << GLEnums::GetStringEnum(format) << ", "
-                 << imageSize << ", " << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCompressedTexSubImage2DFn != nullptr);
-  g_driver_gl.debug_fn.glCompressedTexSubImage2DFn(
-      target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-static void GL_BINDING_CALL Debug_glCompressedTexSubImage3D(GLenum target,
-                                                            GLint level,
-                                                            GLint xoffset,
-                                                            GLint yoffset,
-                                                            GLint zoffset,
-                                                            GLsizei width,
-                                                            GLsizei height,
-                                                            GLsizei depth,
-                                                            GLenum format,
-                                                            GLsizei imageSize,
-                                                            const void* data) {
-  GL_SERVICE_LOG("glCompressedTexSubImage3D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << xoffset << ", " << yoffset << ", " << zoffset
-                 << ", " << width << ", " << height << ", " << depth << ", "
-                 << GLEnums::GetStringEnum(format) << ", " << imageSize << ", "
-                 << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCompressedTexSubImage3DFn != nullptr);
-  g_driver_gl.debug_fn.glCompressedTexSubImage3DFn(
-      target, level, xoffset, yoffset, zoffset, width, height, depth, format,
-      imageSize, data);
-}
-
-static void GL_BINDING_CALL Debug_glCopyBufferSubData(GLenum readTarget,
-                                                      GLenum writeTarget,
-                                                      GLintptr readOffset,
-                                                      GLintptr writeOffset,
-                                                      GLsizeiptr size) {
-  GL_SERVICE_LOG("glCopyBufferSubData"
-                 << "(" << GLEnums::GetStringEnum(readTarget) << ", "
-                 << GLEnums::GetStringEnum(writeTarget) << ", " << readOffset
-                 << ", " << writeOffset << ", " << size << ")");
-  DCHECK(g_driver_gl.debug_fn.glCopyBufferSubDataFn != nullptr);
-  g_driver_gl.debug_fn.glCopyBufferSubDataFn(readTarget, writeTarget,
-                                             readOffset, writeOffset, size);
-}
-
-static void GL_BINDING_CALL
-Debug_glCopySubTextureCHROMIUM(GLuint sourceId,
-                               GLuint destId,
-                               GLint xoffset,
-                               GLint yoffset,
-                               GLint x,
-                               GLint y,
-                               GLsizei width,
-                               GLsizei height,
-                               GLboolean unpackFlipY,
-                               GLboolean unpackPremultiplyAlpha,
-                               GLboolean unpackUnmultiplyAlpha) {
-  GL_SERVICE_LOG("glCopySubTextureCHROMIUM"
-                 << "(" << sourceId << ", " << destId << ", " << xoffset << ", "
-                 << yoffset << ", " << x << ", " << y << ", " << width << ", "
-                 << height << ", " << GLEnums::GetStringBool(unpackFlipY)
-                 << ", " << GLEnums::GetStringBool(unpackPremultiplyAlpha)
-                 << ", " << GLEnums::GetStringBool(unpackUnmultiplyAlpha)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glCopySubTextureCHROMIUMFn != nullptr);
-  g_driver_gl.debug_fn.glCopySubTextureCHROMIUMFn(
-      sourceId, destId, xoffset, yoffset, x, y, width, height, unpackFlipY,
-      unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
-}
-
-static void GL_BINDING_CALL Debug_glCopyTexImage2D(GLenum target,
-                                                   GLint level,
-                                                   GLenum internalformat,
-                                                   GLint x,
-                                                   GLint y,
-                                                   GLsizei width,
-                                                   GLsizei height,
-                                                   GLint border) {
-  GL_SERVICE_LOG("glCopyTexImage2D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", " << x
-                 << ", " << y << ", " << width << ", " << height << ", "
-                 << border << ")");
-  DCHECK(g_driver_gl.debug_fn.glCopyTexImage2DFn != nullptr);
-  g_driver_gl.debug_fn.glCopyTexImage2DFn(target, level, internalformat, x, y,
-                                          width, height, border);
-}
-
-static void GL_BINDING_CALL Debug_glCopyTexSubImage2D(GLenum target,
-                                                      GLint level,
-                                                      GLint xoffset,
-                                                      GLint yoffset,
-                                                      GLint x,
-                                                      GLint y,
-                                                      GLsizei width,
-                                                      GLsizei height) {
-  GL_SERVICE_LOG("glCopyTexSubImage2D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y
-                 << ", " << width << ", " << height << ")");
-  DCHECK(g_driver_gl.debug_fn.glCopyTexSubImage2DFn != nullptr);
-  g_driver_gl.debug_fn.glCopyTexSubImage2DFn(target, level, xoffset, yoffset, x,
-                                             y, width, height);
-}
-
-static void GL_BINDING_CALL Debug_glCopyTexSubImage3D(GLenum target,
-                                                      GLint level,
-                                                      GLint xoffset,
-                                                      GLint yoffset,
-                                                      GLint zoffset,
-                                                      GLint x,
-                                                      GLint y,
-                                                      GLsizei width,
-                                                      GLsizei height) {
-  GL_SERVICE_LOG("glCopyTexSubImage3D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << xoffset << ", " << yoffset << ", " << zoffset
-                 << ", " << x << ", " << y << ", " << width << ", " << height
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glCopyTexSubImage3DFn != nullptr);
-  g_driver_gl.debug_fn.glCopyTexSubImage3DFn(target, level, xoffset, yoffset,
-                                             zoffset, x, y, width, height);
-}
-
-static void GL_BINDING_CALL
-Debug_glCopyTextureCHROMIUM(GLuint sourceId,
-                            GLuint destId,
-                            GLint internalFormat,
-                            GLenum destType,
-                            GLboolean unpackFlipY,
-                            GLboolean unpackPremultiplyAlpha,
-                            GLboolean unpackUnmultiplyAlpha) {
-  GL_SERVICE_LOG("glCopyTextureCHROMIUM"
-                 << "(" << sourceId << ", " << destId << ", " << internalFormat
-                 << ", " << GLEnums::GetStringEnum(destType) << ", "
-                 << GLEnums::GetStringBool(unpackFlipY) << ", "
-                 << GLEnums::GetStringBool(unpackPremultiplyAlpha) << ", "
-                 << GLEnums::GetStringBool(unpackUnmultiplyAlpha) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCopyTextureCHROMIUMFn != nullptr);
-  g_driver_gl.debug_fn.glCopyTextureCHROMIUMFn(
-      sourceId, destId, internalFormat, destType, unpackFlipY,
-      unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
-}
-
-static void GL_BINDING_CALL Debug_glCoverageModulationNV(GLenum components) {
-  GL_SERVICE_LOG("glCoverageModulationNV"
-                 << "(" << GLEnums::GetStringEnum(components) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCoverageModulationNVFn != nullptr);
-  g_driver_gl.debug_fn.glCoverageModulationNVFn(components);
-}
-
-static void GL_BINDING_CALL
-Debug_glCoverFillPathInstancedNV(GLsizei numPaths,
-                                 GLenum pathNameType,
-                                 const void* paths,
-                                 GLuint pathBase,
-                                 GLenum coverMode,
-                                 GLenum transformType,
-                                 const GLfloat* transformValues) {
-  GL_SERVICE_LOG("glCoverFillPathInstancedNV"
-                 << "(" << numPaths << ", "
-                 << GLEnums::GetStringEnum(pathNameType) << ", "
-                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
-                 << GLEnums::GetStringEnum(coverMode) << ", "
-                 << GLEnums::GetStringEnum(transformType) << ", "
-                 << static_cast<const void*>(transformValues) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCoverFillPathInstancedNVFn != nullptr);
-  g_driver_gl.debug_fn.glCoverFillPathInstancedNVFn(
-      numPaths, pathNameType, paths, pathBase, coverMode, transformType,
-      transformValues);
-}
-
-static void GL_BINDING_CALL Debug_glCoverFillPathNV(GLuint path,
-                                                    GLenum coverMode) {
-  GL_SERVICE_LOG("glCoverFillPathNV"
-                 << "(" << path << ", " << GLEnums::GetStringEnum(coverMode)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glCoverFillPathNVFn != nullptr);
-  g_driver_gl.debug_fn.glCoverFillPathNVFn(path, coverMode);
-}
-
-static void GL_BINDING_CALL
-Debug_glCoverStrokePathInstancedNV(GLsizei numPaths,
-                                   GLenum pathNameType,
-                                   const void* paths,
-                                   GLuint pathBase,
-                                   GLenum coverMode,
-                                   GLenum transformType,
-                                   const GLfloat* transformValues) {
-  GL_SERVICE_LOG("glCoverStrokePathInstancedNV"
-                 << "(" << numPaths << ", "
-                 << GLEnums::GetStringEnum(pathNameType) << ", "
-                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
-                 << GLEnums::GetStringEnum(coverMode) << ", "
-                 << GLEnums::GetStringEnum(transformType) << ", "
-                 << static_cast<const void*>(transformValues) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCoverStrokePathInstancedNVFn != nullptr);
-  g_driver_gl.debug_fn.glCoverStrokePathInstancedNVFn(
-      numPaths, pathNameType, paths, pathBase, coverMode, transformType,
-      transformValues);
-}
-
-static void GL_BINDING_CALL Debug_glCoverStrokePathNV(GLuint name,
-                                                      GLenum coverMode) {
-  GL_SERVICE_LOG("glCoverStrokePathNV"
-                 << "(" << name << ", " << GLEnums::GetStringEnum(coverMode)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glCoverStrokePathNVFn != nullptr);
-  g_driver_gl.debug_fn.glCoverStrokePathNVFn(name, coverMode);
-}
-
-static GLuint GL_BINDING_CALL Debug_glCreateProgram(void) {
-  GL_SERVICE_LOG("glCreateProgram"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glCreateProgramFn != nullptr);
-  GLuint result = g_driver_gl.debug_fn.glCreateProgramFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLuint GL_BINDING_CALL Debug_glCreateShader(GLenum type) {
-  GL_SERVICE_LOG("glCreateShader"
-                 << "(" << GLEnums::GetStringEnum(type) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCreateShaderFn != nullptr);
-  GLuint result = g_driver_gl.debug_fn.glCreateShaderFn(type);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glCullFace(GLenum mode) {
-  GL_SERVICE_LOG("glCullFace"
-                 << "(" << GLEnums::GetStringEnum(mode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glCullFaceFn != nullptr);
-  g_driver_gl.debug_fn.glCullFaceFn(mode);
-}
-
-static void GL_BINDING_CALL
-Debug_glDebugMessageCallback(GLDEBUGPROC callback, const void* userParam) {
-  GL_SERVICE_LOG("glDebugMessageCallback"
-                 << "(" << callback << ", "
-                 << static_cast<const void*>(userParam) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDebugMessageCallbackFn != nullptr);
-  g_driver_gl.debug_fn.glDebugMessageCallbackFn(callback, userParam);
-}
-
-static void GL_BINDING_CALL Debug_glDebugMessageControl(GLenum source,
-                                                        GLenum type,
-                                                        GLenum severity,
-                                                        GLsizei count,
-                                                        const GLuint* ids,
-                                                        GLboolean enabled) {
-  GL_SERVICE_LOG("glDebugMessageControl"
-                 << "(" << GLEnums::GetStringEnum(source) << ", "
-                 << GLEnums::GetStringEnum(type) << ", "
-                 << GLEnums::GetStringEnum(severity) << ", " << count << ", "
-                 << static_cast<const void*>(ids) << ", "
-                 << GLEnums::GetStringBool(enabled) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDebugMessageControlFn != nullptr);
-  g_driver_gl.debug_fn.glDebugMessageControlFn(source, type, severity, count,
-                                               ids, enabled);
-}
-
-static void GL_BINDING_CALL Debug_glDebugMessageInsert(GLenum source,
-                                                       GLenum type,
-                                                       GLuint id,
-                                                       GLenum severity,
-                                                       GLsizei length,
-                                                       const char* buf) {
-  GL_SERVICE_LOG("glDebugMessageInsert"
-                 << "(" << GLEnums::GetStringEnum(source) << ", "
-                 << GLEnums::GetStringEnum(type) << ", " << id << ", "
-                 << GLEnums::GetStringEnum(severity) << ", " << length << ", "
-                 << buf << ")");
-  DCHECK(g_driver_gl.debug_fn.glDebugMessageInsertFn != nullptr);
-  g_driver_gl.debug_fn.glDebugMessageInsertFn(source, type, id, severity,
-                                              length, buf);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteBuffersARB(GLsizei n,
-                                                     const GLuint* buffers) {
-  GL_SERVICE_LOG("glDeleteBuffersARB"
-                 << "(" << n << ", " << static_cast<const void*>(buffers)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteBuffersARBFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteBuffersARBFn(n, buffers);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteFencesAPPLE(GLsizei n,
-                                                      const GLuint* fences) {
-  GL_SERVICE_LOG("glDeleteFencesAPPLE"
-                 << "(" << n << ", " << static_cast<const void*>(fences)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteFencesAPPLEFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteFencesAPPLEFn(n, fences);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteFencesNV(GLsizei n,
-                                                   const GLuint* fences) {
-  GL_SERVICE_LOG("glDeleteFencesNV"
-                 << "(" << n << ", " << static_cast<const void*>(fences)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteFencesNVFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteFencesNVFn(n, fences);
-}
-
-static void GL_BINDING_CALL
-Debug_glDeleteFramebuffersEXT(GLsizei n, const GLuint* framebuffers) {
-  GL_SERVICE_LOG("glDeleteFramebuffersEXT"
-                 << "(" << n << ", " << static_cast<const void*>(framebuffers)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteFramebuffersEXTFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteFramebuffersEXTFn(n, framebuffers);
-}
-
-static void GL_BINDING_CALL Debug_glDeletePathsNV(GLuint path, GLsizei range) {
-  GL_SERVICE_LOG("glDeletePathsNV"
-                 << "(" << path << ", " << range << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeletePathsNVFn != nullptr);
-  g_driver_gl.debug_fn.glDeletePathsNVFn(path, range);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteProgram(GLuint program) {
-  GL_SERVICE_LOG("glDeleteProgram"
-                 << "(" << program << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteProgramFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteProgramFn(program);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteQueries(GLsizei n,
-                                                  const GLuint* ids) {
-  GL_SERVICE_LOG("glDeleteQueries"
-                 << "(" << n << ", " << static_cast<const void*>(ids) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteQueriesFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteQueriesFn(n, ids);
-}
-
-static void GL_BINDING_CALL
-Debug_glDeleteRenderbuffersEXT(GLsizei n, const GLuint* renderbuffers) {
-  GL_SERVICE_LOG("glDeleteRenderbuffersEXT"
-                 << "(" << n << ", " << static_cast<const void*>(renderbuffers)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteRenderbuffersEXTFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteRenderbuffersEXTFn(n, renderbuffers);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteSamplers(GLsizei n,
-                                                   const GLuint* samplers) {
-  GL_SERVICE_LOG("glDeleteSamplers"
-                 << "(" << n << ", " << static_cast<const void*>(samplers)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteSamplersFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteSamplersFn(n, samplers);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteShader(GLuint shader) {
-  GL_SERVICE_LOG("glDeleteShader"
-                 << "(" << shader << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteShaderFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteShaderFn(shader);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteSync(GLsync sync) {
-  GL_SERVICE_LOG("glDeleteSync"
-                 << "(" << sync << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteSyncFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteSyncFn(sync);
-}
-
-static void GL_BINDING_CALL Debug_glDeleteTextures(GLsizei n,
-                                                   const GLuint* textures) {
-  GL_SERVICE_LOG("glDeleteTextures"
-                 << "(" << n << ", " << static_cast<const void*>(textures)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteTexturesFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteTexturesFn(n, textures);
-}
-
-static void GL_BINDING_CALL
-Debug_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
-  GL_SERVICE_LOG("glDeleteTransformFeedbacks"
-                 << "(" << n << ", " << static_cast<const void*>(ids) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteTransformFeedbacksFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteTransformFeedbacksFn(n, ids);
-}
-
-static void GL_BINDING_CALL
-Debug_glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
-  GL_SERVICE_LOG("glDeleteVertexArraysOES"
-                 << "(" << n << ", " << static_cast<const void*>(arrays)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDeleteVertexArraysOESFn != nullptr);
-  g_driver_gl.debug_fn.glDeleteVertexArraysOESFn(n, arrays);
-}
-
-static void GL_BINDING_CALL Debug_glDepthFunc(GLenum func) {
-  GL_SERVICE_LOG("glDepthFunc"
-                 << "(" << GLEnums::GetStringEnum(func) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDepthFuncFn != nullptr);
-  g_driver_gl.debug_fn.glDepthFuncFn(func);
-}
-
-static void GL_BINDING_CALL Debug_glDepthMask(GLboolean flag) {
-  GL_SERVICE_LOG("glDepthMask"
-                 << "(" << GLEnums::GetStringBool(flag) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDepthMaskFn != nullptr);
-  g_driver_gl.debug_fn.glDepthMaskFn(flag);
-}
-
-static void GL_BINDING_CALL Debug_glDepthRange(GLclampd zNear, GLclampd zFar) {
-  GL_SERVICE_LOG("glDepthRange"
-                 << "(" << zNear << ", " << zFar << ")");
-  DCHECK(g_driver_gl.debug_fn.glDepthRangeFn != nullptr);
-  g_driver_gl.debug_fn.glDepthRangeFn(zNear, zFar);
-}
-
-static void GL_BINDING_CALL Debug_glDepthRangef(GLclampf zNear, GLclampf zFar) {
-  GL_SERVICE_LOG("glDepthRangef"
-                 << "(" << zNear << ", " << zFar << ")");
-  DCHECK(g_driver_gl.debug_fn.glDepthRangefFn != nullptr);
-  g_driver_gl.debug_fn.glDepthRangefFn(zNear, zFar);
-}
-
-static void GL_BINDING_CALL Debug_glDetachShader(GLuint program,
-                                                 GLuint shader) {
-  GL_SERVICE_LOG("glDetachShader"
-                 << "(" << program << ", " << shader << ")");
-  DCHECK(g_driver_gl.debug_fn.glDetachShaderFn != nullptr);
-  g_driver_gl.debug_fn.glDetachShaderFn(program, shader);
-}
-
-static void GL_BINDING_CALL Debug_glDisable(GLenum cap) {
-  GL_SERVICE_LOG("glDisable"
-                 << "(" << GLEnums::GetStringEnum(cap) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDisableFn != nullptr);
-  g_driver_gl.debug_fn.glDisableFn(cap);
-}
-
-static void GL_BINDING_CALL Debug_glDisableVertexAttribArray(GLuint index) {
-  GL_SERVICE_LOG("glDisableVertexAttribArray"
-                 << "(" << index << ")");
-  DCHECK(g_driver_gl.debug_fn.glDisableVertexAttribArrayFn != nullptr);
-  g_driver_gl.debug_fn.glDisableVertexAttribArrayFn(index);
-}
-
-static void GL_BINDING_CALL
-Debug_glDiscardFramebufferEXT(GLenum target,
-                              GLsizei numAttachments,
-                              const GLenum* attachments) {
-  GL_SERVICE_LOG("glDiscardFramebufferEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << numAttachments << ", "
-                 << static_cast<const void*>(attachments) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDiscardFramebufferEXTFn != nullptr);
-  g_driver_gl.debug_fn.glDiscardFramebufferEXTFn(target, numAttachments,
-                                                 attachments);
-}
-
-static void GL_BINDING_CALL Debug_glDrawArrays(GLenum mode,
-                                               GLint first,
-                                               GLsizei count) {
-  GL_SERVICE_LOG("glDrawArrays"
-                 << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", "
-                 << count << ")");
-  DCHECK(g_driver_gl.debug_fn.glDrawArraysFn != nullptr);
-  g_driver_gl.debug_fn.glDrawArraysFn(mode, first, count);
-}
-
-static void GL_BINDING_CALL
-Debug_glDrawArraysInstancedANGLE(GLenum mode,
-                                 GLint first,
-                                 GLsizei count,
-                                 GLsizei primcount) {
-  GL_SERVICE_LOG("glDrawArraysInstancedANGLE"
-                 << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", "
-                 << count << ", " << primcount << ")");
-  DCHECK(g_driver_gl.debug_fn.glDrawArraysInstancedANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glDrawArraysInstancedANGLEFn(mode, first, count,
-                                                    primcount);
-}
-
-static void GL_BINDING_CALL Debug_glDrawBuffer(GLenum mode) {
-  GL_SERVICE_LOG("glDrawBuffer"
-                 << "(" << GLEnums::GetStringEnum(mode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDrawBufferFn != nullptr);
-  g_driver_gl.debug_fn.glDrawBufferFn(mode);
-}
-
-static void GL_BINDING_CALL Debug_glDrawBuffersARB(GLsizei n,
-                                                   const GLenum* bufs) {
-  GL_SERVICE_LOG("glDrawBuffersARB"
-                 << "(" << n << ", " << static_cast<const void*>(bufs) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDrawBuffersARBFn != nullptr);
-  g_driver_gl.debug_fn.glDrawBuffersARBFn(n, bufs);
-}
-
-static void GL_BINDING_CALL Debug_glDrawElements(GLenum mode,
-                                                 GLsizei count,
-                                                 GLenum type,
-                                                 const void* indices) {
-  GL_SERVICE_LOG("glDrawElements"
-                 << "(" << GLEnums::GetStringEnum(mode) << ", " << count << ", "
-                 << GLEnums::GetStringEnum(type) << ", "
-                 << static_cast<const void*>(indices) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDrawElementsFn != nullptr);
-  g_driver_gl.debug_fn.glDrawElementsFn(mode, count, type, indices);
-}
-
-static void GL_BINDING_CALL
-Debug_glDrawElementsInstancedANGLE(GLenum mode,
-                                   GLsizei count,
-                                   GLenum type,
-                                   const void* indices,
-                                   GLsizei primcount) {
-  GL_SERVICE_LOG("glDrawElementsInstancedANGLE"
-                 << "(" << GLEnums::GetStringEnum(mode) << ", " << count << ", "
-                 << GLEnums::GetStringEnum(type) << ", "
-                 << static_cast<const void*>(indices) << ", " << primcount
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glDrawElementsInstancedANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glDrawElementsInstancedANGLEFn(mode, count, type,
-                                                      indices, primcount);
-}
-
-static void GL_BINDING_CALL Debug_glDrawRangeElements(GLenum mode,
-                                                      GLuint start,
-                                                      GLuint end,
-                                                      GLsizei count,
-                                                      GLenum type,
-                                                      const void* indices) {
-  GL_SERVICE_LOG("glDrawRangeElements"
-                 << "(" << GLEnums::GetStringEnum(mode) << ", " << start << ", "
-                 << end << ", " << count << ", " << GLEnums::GetStringEnum(type)
-                 << ", " << static_cast<const void*>(indices) << ")");
-  DCHECK(g_driver_gl.debug_fn.glDrawRangeElementsFn != nullptr);
-  g_driver_gl.debug_fn.glDrawRangeElementsFn(mode, start, end, count, type,
-                                             indices);
-}
-
-static void GL_BINDING_CALL
-Debug_glEGLImageTargetRenderbufferStorageOES(GLenum target,
-                                             GLeglImageOES image) {
-  GL_SERVICE_LOG("glEGLImageTargetRenderbufferStorageOES"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << image
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glEGLImageTargetRenderbufferStorageOESFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glEGLImageTargetRenderbufferStorageOESFn(target, image);
-}
-
-static void GL_BINDING_CALL
-Debug_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) {
-  GL_SERVICE_LOG("glEGLImageTargetTexture2DOES"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << image
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glEGLImageTargetTexture2DOESFn != nullptr);
-  g_driver_gl.debug_fn.glEGLImageTargetTexture2DOESFn(target, image);
-}
-
-static void GL_BINDING_CALL Debug_glEnable(GLenum cap) {
-  GL_SERVICE_LOG("glEnable"
-                 << "(" << GLEnums::GetStringEnum(cap) << ")");
-  DCHECK(g_driver_gl.debug_fn.glEnableFn != nullptr);
-  g_driver_gl.debug_fn.glEnableFn(cap);
-}
-
-static void GL_BINDING_CALL Debug_glEnableVertexAttribArray(GLuint index) {
-  GL_SERVICE_LOG("glEnableVertexAttribArray"
-                 << "(" << index << ")");
-  DCHECK(g_driver_gl.debug_fn.glEnableVertexAttribArrayFn != nullptr);
-  g_driver_gl.debug_fn.glEnableVertexAttribArrayFn(index);
-}
-
-static void GL_BINDING_CALL Debug_glEndQuery(GLenum target) {
-  GL_SERVICE_LOG("glEndQuery"
-                 << "(" << GLEnums::GetStringEnum(target) << ")");
-  DCHECK(g_driver_gl.debug_fn.glEndQueryFn != nullptr);
-  g_driver_gl.debug_fn.glEndQueryFn(target);
-}
-
-static void GL_BINDING_CALL Debug_glEndTransformFeedback(void) {
-  GL_SERVICE_LOG("glEndTransformFeedback"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glEndTransformFeedbackFn != nullptr);
-  g_driver_gl.debug_fn.glEndTransformFeedbackFn();
-}
-
-static GLsync GL_BINDING_CALL Debug_glFenceSync(GLenum condition,
-                                                GLbitfield flags) {
-  GL_SERVICE_LOG("glFenceSync"
-                 << "(" << GLEnums::GetStringEnum(condition) << ", " << flags
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glFenceSyncFn != nullptr);
-  GLsync result = g_driver_gl.debug_fn.glFenceSyncFn(condition, flags);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glFinish(void) {
-  GL_SERVICE_LOG("glFinish"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glFinishFn != nullptr);
-  g_driver_gl.debug_fn.glFinishFn();
-}
-
-static void GL_BINDING_CALL Debug_glFinishFenceAPPLE(GLuint fence) {
-  GL_SERVICE_LOG("glFinishFenceAPPLE"
-                 << "(" << fence << ")");
-  DCHECK(g_driver_gl.debug_fn.glFinishFenceAPPLEFn != nullptr);
-  g_driver_gl.debug_fn.glFinishFenceAPPLEFn(fence);
-}
-
-static void GL_BINDING_CALL Debug_glFinishFenceNV(GLuint fence) {
-  GL_SERVICE_LOG("glFinishFenceNV"
-                 << "(" << fence << ")");
-  DCHECK(g_driver_gl.debug_fn.glFinishFenceNVFn != nullptr);
-  g_driver_gl.debug_fn.glFinishFenceNVFn(fence);
-}
-
-static void GL_BINDING_CALL Debug_glFlush(void) {
-  GL_SERVICE_LOG("glFlush"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glFlushFn != nullptr);
-  g_driver_gl.debug_fn.glFlushFn();
-}
-
-static void GL_BINDING_CALL Debug_glFlushMappedBufferRange(GLenum target,
-                                                           GLintptr offset,
-                                                           GLsizeiptr length) {
-  GL_SERVICE_LOG("glFlushMappedBufferRange"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << offset
-                 << ", " << length << ")");
-  DCHECK(g_driver_gl.debug_fn.glFlushMappedBufferRangeFn != nullptr);
-  g_driver_gl.debug_fn.glFlushMappedBufferRangeFn(target, offset, length);
-}
-
-static void GL_BINDING_CALL
-Debug_glFramebufferRenderbufferEXT(GLenum target,
-                                   GLenum attachment,
-                                   GLenum renderbuffertarget,
-                                   GLuint renderbuffer) {
-  GL_SERVICE_LOG("glFramebufferRenderbufferEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(attachment) << ", "
-                 << GLEnums::GetStringEnum(renderbuffertarget) << ", "
-                 << renderbuffer << ")");
-  DCHECK(g_driver_gl.debug_fn.glFramebufferRenderbufferEXTFn != nullptr);
-  g_driver_gl.debug_fn.glFramebufferRenderbufferEXTFn(
-      target, attachment, renderbuffertarget, renderbuffer);
-}
-
-static void GL_BINDING_CALL Debug_glFramebufferTexture2DEXT(GLenum target,
-                                                            GLenum attachment,
-                                                            GLenum textarget,
-                                                            GLuint texture,
-                                                            GLint level) {
-  GL_SERVICE_LOG("glFramebufferTexture2DEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(attachment) << ", "
-                 << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
-                 << level << ")");
-  DCHECK(g_driver_gl.debug_fn.glFramebufferTexture2DEXTFn != nullptr);
-  g_driver_gl.debug_fn.glFramebufferTexture2DEXTFn(target, attachment,
-                                                   textarget, texture, level);
-}
-
-static void GL_BINDING_CALL
-Debug_glFramebufferTexture2DMultisampleEXT(GLenum target,
-                                           GLenum attachment,
-                                           GLenum textarget,
-                                           GLuint texture,
-                                           GLint level,
-                                           GLsizei samples) {
-  GL_SERVICE_LOG("glFramebufferTexture2DMultisampleEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(attachment) << ", "
-                 << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
-                 << level << ", " << samples << ")");
-  DCHECK(g_driver_gl.debug_fn.glFramebufferTexture2DMultisampleEXTFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glFramebufferTexture2DMultisampleEXTFn(
-      target, attachment, textarget, texture, level, samples);
-}
-
-static void GL_BINDING_CALL
-Debug_glFramebufferTexture2DMultisampleIMG(GLenum target,
-                                           GLenum attachment,
-                                           GLenum textarget,
-                                           GLuint texture,
-                                           GLint level,
-                                           GLsizei samples) {
-  GL_SERVICE_LOG("glFramebufferTexture2DMultisampleIMG"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(attachment) << ", "
-                 << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
-                 << level << ", " << samples << ")");
-  DCHECK(g_driver_gl.debug_fn.glFramebufferTexture2DMultisampleIMGFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glFramebufferTexture2DMultisampleIMGFn(
-      target, attachment, textarget, texture, level, samples);
-}
-
-static void GL_BINDING_CALL Debug_glFramebufferTextureLayer(GLenum target,
-                                                            GLenum attachment,
-                                                            GLuint texture,
-                                                            GLint level,
-                                                            GLint layer) {
-  GL_SERVICE_LOG("glFramebufferTextureLayer"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(attachment) << ", " << texture
-                 << ", " << level << ", " << layer << ")");
-  DCHECK(g_driver_gl.debug_fn.glFramebufferTextureLayerFn != nullptr);
-  g_driver_gl.debug_fn.glFramebufferTextureLayerFn(target, attachment, texture,
-                                                   level, layer);
-}
-
-static void GL_BINDING_CALL Debug_glFrontFace(GLenum mode) {
-  GL_SERVICE_LOG("glFrontFace"
-                 << "(" << GLEnums::GetStringEnum(mode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glFrontFaceFn != nullptr);
-  g_driver_gl.debug_fn.glFrontFaceFn(mode);
-}
-
-static void GL_BINDING_CALL Debug_glGenBuffersARB(GLsizei n, GLuint* buffers) {
-  GL_SERVICE_LOG("glGenBuffersARB"
-                 << "(" << n << ", " << static_cast<const void*>(buffers)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenBuffersARBFn != nullptr);
-  g_driver_gl.debug_fn.glGenBuffersARBFn(n, buffers);
-}
-
-static void GL_BINDING_CALL Debug_glGenerateMipmapEXT(GLenum target) {
-  GL_SERVICE_LOG("glGenerateMipmapEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenerateMipmapEXTFn != nullptr);
-  g_driver_gl.debug_fn.glGenerateMipmapEXTFn(target);
-}
-
-static void GL_BINDING_CALL Debug_glGenFencesAPPLE(GLsizei n, GLuint* fences) {
-  GL_SERVICE_LOG("glGenFencesAPPLE"
-                 << "(" << n << ", " << static_cast<const void*>(fences)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenFencesAPPLEFn != nullptr);
-  g_driver_gl.debug_fn.glGenFencesAPPLEFn(n, fences);
-}
-
-static void GL_BINDING_CALL Debug_glGenFencesNV(GLsizei n, GLuint* fences) {
-  GL_SERVICE_LOG("glGenFencesNV"
-                 << "(" << n << ", " << static_cast<const void*>(fences)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenFencesNVFn != nullptr);
-  g_driver_gl.debug_fn.glGenFencesNVFn(n, fences);
-}
-
-static void GL_BINDING_CALL Debug_glGenFramebuffersEXT(GLsizei n,
-                                                       GLuint* framebuffers) {
-  GL_SERVICE_LOG("glGenFramebuffersEXT"
-                 << "(" << n << ", " << static_cast<const void*>(framebuffers)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenFramebuffersEXTFn != nullptr);
-  g_driver_gl.debug_fn.glGenFramebuffersEXTFn(n, framebuffers);
-}
-
-static GLuint GL_BINDING_CALL Debug_glGenPathsNV(GLsizei range) {
-  GL_SERVICE_LOG("glGenPathsNV"
-                 << "(" << range << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenPathsNVFn != nullptr);
-  GLuint result = g_driver_gl.debug_fn.glGenPathsNVFn(range);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glGenQueries(GLsizei n, GLuint* ids) {
-  GL_SERVICE_LOG("glGenQueries"
-                 << "(" << n << ", " << static_cast<const void*>(ids) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenQueriesFn != nullptr);
-  g_driver_gl.debug_fn.glGenQueriesFn(n, ids);
-}
-
-static void GL_BINDING_CALL Debug_glGenRenderbuffersEXT(GLsizei n,
-                                                        GLuint* renderbuffers) {
-  GL_SERVICE_LOG("glGenRenderbuffersEXT"
-                 << "(" << n << ", " << static_cast<const void*>(renderbuffers)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenRenderbuffersEXTFn != nullptr);
-  g_driver_gl.debug_fn.glGenRenderbuffersEXTFn(n, renderbuffers);
-}
-
-static void GL_BINDING_CALL Debug_glGenSamplers(GLsizei n, GLuint* samplers) {
-  GL_SERVICE_LOG("glGenSamplers"
-                 << "(" << n << ", " << static_cast<const void*>(samplers)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenSamplersFn != nullptr);
-  g_driver_gl.debug_fn.glGenSamplersFn(n, samplers);
-}
-
-static void GL_BINDING_CALL Debug_glGenTextures(GLsizei n, GLuint* textures) {
-  GL_SERVICE_LOG("glGenTextures"
-                 << "(" << n << ", " << static_cast<const void*>(textures)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenTexturesFn != nullptr);
-  g_driver_gl.debug_fn.glGenTexturesFn(n, textures);
-}
-
-static void GL_BINDING_CALL Debug_glGenTransformFeedbacks(GLsizei n,
-                                                          GLuint* ids) {
-  GL_SERVICE_LOG("glGenTransformFeedbacks"
-                 << "(" << n << ", " << static_cast<const void*>(ids) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenTransformFeedbacksFn != nullptr);
-  g_driver_gl.debug_fn.glGenTransformFeedbacksFn(n, ids);
-}
-
-static void GL_BINDING_CALL Debug_glGenVertexArraysOES(GLsizei n,
-                                                       GLuint* arrays) {
-  GL_SERVICE_LOG("glGenVertexArraysOES"
-                 << "(" << n << ", " << static_cast<const void*>(arrays)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGenVertexArraysOESFn != nullptr);
-  g_driver_gl.debug_fn.glGenVertexArraysOESFn(n, arrays);
-}
-
-static void GL_BINDING_CALL Debug_glGetActiveAttrib(GLuint program,
-                                                    GLuint index,
-                                                    GLsizei bufsize,
-                                                    GLsizei* length,
-                                                    GLint* size,
-                                                    GLenum* type,
-                                                    char* name) {
-  GL_SERVICE_LOG("glGetActiveAttrib"
-                 << "(" << program << ", " << index << ", " << bufsize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(size) << ", "
-                 << static_cast<const void*>(type) << ", "
-                 << static_cast<const void*>(name) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetActiveAttribFn != nullptr);
-  g_driver_gl.debug_fn.glGetActiveAttribFn(program, index, bufsize, length,
-                                           size, type, name);
-}
-
-static void GL_BINDING_CALL Debug_glGetActiveUniform(GLuint program,
-                                                     GLuint index,
-                                                     GLsizei bufsize,
-                                                     GLsizei* length,
-                                                     GLint* size,
-                                                     GLenum* type,
-                                                     char* name) {
-  GL_SERVICE_LOG("glGetActiveUniform"
-                 << "(" << program << ", " << index << ", " << bufsize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(size) << ", "
-                 << static_cast<const void*>(type) << ", "
-                 << static_cast<const void*>(name) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformFn != nullptr);
-  g_driver_gl.debug_fn.glGetActiveUniformFn(program, index, bufsize, length,
-                                            size, type, name);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetActiveUniformBlockiv(GLuint program,
-                                GLuint uniformBlockIndex,
-                                GLenum pname,
-                                GLint* params) {
-  GL_SERVICE_LOG("glGetActiveUniformBlockiv"
-                 << "(" << program << ", " << uniformBlockIndex << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformBlockivFn != nullptr);
-  g_driver_gl.debug_fn.glGetActiveUniformBlockivFn(program, uniformBlockIndex,
-                                                   pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetActiveUniformBlockivRobustANGLE(GLuint program,
-                                           GLuint uniformBlockIndex,
-                                           GLenum pname,
-                                           GLsizei bufSize,
-                                           GLsizei* length,
-                                           GLint* params) {
-  GL_SERVICE_LOG("glGetActiveUniformBlockivRobustANGLE"
-                 << "(" << program << ", " << uniformBlockIndex << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformBlockivRobustANGLEFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glGetActiveUniformBlockivRobustANGLEFn(
-      program, uniformBlockIndex, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetActiveUniformBlockName(GLuint program,
-                                  GLuint uniformBlockIndex,
-                                  GLsizei bufSize,
-                                  GLsizei* length,
-                                  char* uniformBlockName) {
-  GL_SERVICE_LOG("glGetActiveUniformBlockName"
-                 << "(" << program << ", " << uniformBlockIndex << ", "
-                 << bufSize << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(uniformBlockName) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformBlockNameFn != nullptr);
-  g_driver_gl.debug_fn.glGetActiveUniformBlockNameFn(
-      program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetActiveUniformsiv(GLuint program,
-                            GLsizei uniformCount,
-                            const GLuint* uniformIndices,
-                            GLenum pname,
-                            GLint* params) {
-  GL_SERVICE_LOG("glGetActiveUniformsiv"
-                 << "(" << program << ", " << uniformCount << ", "
-                 << static_cast<const void*>(uniformIndices) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformsivFn != nullptr);
-  g_driver_gl.debug_fn.glGetActiveUniformsivFn(program, uniformCount,
-                                               uniformIndices, pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetAttachedShaders(GLuint program,
-                                                       GLsizei maxcount,
-                                                       GLsizei* count,
-                                                       GLuint* shaders) {
-  GL_SERVICE_LOG("glGetAttachedShaders"
-                 << "(" << program << ", " << maxcount << ", "
-                 << static_cast<const void*>(count) << ", "
-                 << static_cast<const void*>(shaders) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetAttachedShadersFn != nullptr);
-  g_driver_gl.debug_fn.glGetAttachedShadersFn(program, maxcount, count,
-                                              shaders);
-}
-
-static GLint GL_BINDING_CALL Debug_glGetAttribLocation(GLuint program,
-                                                       const char* name) {
-  GL_SERVICE_LOG("glGetAttribLocation"
-                 << "(" << program << ", " << name << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetAttribLocationFn != nullptr);
-  GLint result = g_driver_gl.debug_fn.glGetAttribLocationFn(program, name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glGetBooleani_vRobustANGLE(GLenum target,
-                                                             GLuint index,
-                                                             GLsizei bufSize,
-                                                             GLsizei* length,
-                                                             GLboolean* data) {
-  GL_SERVICE_LOG("glGetBooleani_vRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetBooleani_vRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetBooleani_vRobustANGLEFn(target, index, bufSize,
-                                                    length, data);
-}
-
-static void GL_BINDING_CALL Debug_glGetBooleanv(GLenum pname,
-                                                GLboolean* params) {
-  GL_SERVICE_LOG("glGetBooleanv"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetBooleanvFn != nullptr);
-  g_driver_gl.debug_fn.glGetBooleanvFn(pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetBooleanvRobustANGLE(GLenum pname,
-                                                           GLsizei bufSize,
-                                                           GLsizei* length,
-                                                           GLboolean* data) {
-  GL_SERVICE_LOG("glGetBooleanvRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetBooleanvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetBooleanvRobustANGLEFn(pname, bufSize, length, data);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetBufferParameteri64vRobustANGLE(GLenum target,
-                                          GLenum pname,
-                                          GLsizei bufSize,
-                                          GLsizei* length,
-                                          GLint64* params) {
-  GL_SERVICE_LOG("glGetBufferParameteri64vRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetBufferParameteri64vRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetBufferParameteri64vRobustANGLEFn(
-      target, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetBufferParameteriv(GLenum target,
-                                                         GLenum pname,
-                                                         GLint* params) {
-  GL_SERVICE_LOG("glGetBufferParameteriv"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetBufferParameterivFn != nullptr);
-  g_driver_gl.debug_fn.glGetBufferParameterivFn(target, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetBufferParameterivRobustANGLE(GLenum target,
-                                        GLenum pname,
-                                        GLsizei bufSize,
-                                        GLsizei* length,
-                                        GLint* params) {
-  GL_SERVICE_LOG("glGetBufferParameterivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetBufferParameterivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetBufferParameterivRobustANGLEFn(
-      target, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetBufferPointervRobustANGLE(GLenum target,
-                                     GLenum pname,
-                                     GLsizei bufSize,
-                                     GLsizei* length,
-                                     void** params) {
-  GL_SERVICE_LOG("glGetBufferPointervRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", " << params << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetBufferPointervRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetBufferPointervRobustANGLEFn(target, pname, bufSize,
-                                                        length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetDebugMessageLog(GLuint count,
-                                                       GLsizei bufSize,
-                                                       GLenum* sources,
-                                                       GLenum* types,
-                                                       GLuint* ids,
-                                                       GLenum* severities,
-                                                       GLsizei* lengths,
-                                                       char* messageLog) {
-  GL_SERVICE_LOG("glGetDebugMessageLog"
-                 << "(" << count << ", " << bufSize << ", "
-                 << static_cast<const void*>(sources) << ", "
-                 << static_cast<const void*>(types) << ", "
-                 << static_cast<const void*>(ids) << ", "
-                 << static_cast<const void*>(severities) << ", "
-                 << static_cast<const void*>(lengths) << ", "
-                 << static_cast<const void*>(messageLog) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetDebugMessageLogFn != nullptr);
-  g_driver_gl.debug_fn.glGetDebugMessageLogFn(
-      count, bufSize, sources, types, ids, severities, lengths, messageLog);
-}
-
-static GLenum GL_BINDING_CALL Debug_glGetError(void) {
-  GL_SERVICE_LOG("glGetError"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetErrorFn != nullptr);
-  GLenum result = g_driver_gl.debug_fn.glGetErrorFn();
-
-  GL_SERVICE_LOG("GL_RESULT: " << GLEnums::GetStringError(result));
-
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glGetFenceivNV(GLuint fence,
-                                                 GLenum pname,
-                                                 GLint* params) {
-  GL_SERVICE_LOG("glGetFenceivNV"
-                 << "(" << fence << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetFenceivNVFn != nullptr);
-  g_driver_gl.debug_fn.glGetFenceivNVFn(fence, pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetFloatv(GLenum pname, GLfloat* params) {
-  GL_SERVICE_LOG("glGetFloatv"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetFloatvFn != nullptr);
-  g_driver_gl.debug_fn.glGetFloatvFn(pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetFloatvRobustANGLE(GLenum pname,
-                                                         GLsizei bufSize,
-                                                         GLsizei* length,
-                                                         GLfloat* data) {
-  GL_SERVICE_LOG("glGetFloatvRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetFloatvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetFloatvRobustANGLEFn(pname, bufSize, length, data);
-}
-
-static GLint GL_BINDING_CALL Debug_glGetFragDataIndex(GLuint program,
-                                                      const char* name) {
-  GL_SERVICE_LOG("glGetFragDataIndex"
-                 << "(" << program << ", " << name << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetFragDataIndexFn != nullptr);
-  GLint result = g_driver_gl.debug_fn.glGetFragDataIndexFn(program, name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLint GL_BINDING_CALL Debug_glGetFragDataLocation(GLuint program,
-                                                         const char* name) {
-  GL_SERVICE_LOG("glGetFragDataLocation"
-                 << "(" << program << ", " << name << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetFragDataLocationFn != nullptr);
-  GLint result = g_driver_gl.debug_fn.glGetFragDataLocationFn(program, name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL
-Debug_glGetFramebufferAttachmentParameterivEXT(GLenum target,
-                                               GLenum attachment,
-                                               GLenum pname,
-                                               GLint* params) {
-  GL_SERVICE_LOG("glGetFramebufferAttachmentParameterivEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(attachment) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetFramebufferAttachmentParameterivEXTFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glGetFramebufferAttachmentParameterivEXTFn(
-      target, attachment, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
-                                                       GLenum attachment,
-                                                       GLenum pname,
-                                                       GLsizei bufSize,
-                                                       GLsizei* length,
-                                                       GLint* params) {
-  GL_SERVICE_LOG("glGetFramebufferAttachmentParameterivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(attachment) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(
-      g_driver_gl.debug_fn.glGetFramebufferAttachmentParameterivRobustANGLEFn !=
-      nullptr);
-  g_driver_gl.debug_fn.glGetFramebufferAttachmentParameterivRobustANGLEFn(
-      target, attachment, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetFramebufferParameterivRobustANGLE(GLenum target,
-                                             GLenum pname,
-                                             GLsizei bufSize,
-                                             GLsizei* length,
-                                             GLint* params) {
-  GL_SERVICE_LOG("glGetFramebufferParameterivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetFramebufferParameterivRobustANGLEFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glGetFramebufferParameterivRobustANGLEFn(
-      target, pname, bufSize, length, params);
-}
-
-static GLenum GL_BINDING_CALL Debug_glGetGraphicsResetStatusARB(void) {
-  GL_SERVICE_LOG("glGetGraphicsResetStatusARB"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetGraphicsResetStatusARBFn != nullptr);
-  GLenum result = g_driver_gl.debug_fn.glGetGraphicsResetStatusARBFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glGetInteger64i_v(GLenum target,
-                                                    GLuint index,
-                                                    GLint64* data) {
-  GL_SERVICE_LOG("glGetInteger64i_v"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
-                 << ", " << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetInteger64i_vFn != nullptr);
-  g_driver_gl.debug_fn.glGetInteger64i_vFn(target, index, data);
-}
-
-static void GL_BINDING_CALL Debug_glGetInteger64i_vRobustANGLE(GLenum target,
-                                                               GLuint index,
-                                                               GLsizei bufSize,
-                                                               GLsizei* length,
-                                                               GLint64* data) {
-  GL_SERVICE_LOG("glGetInteger64i_vRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetInteger64i_vRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetInteger64i_vRobustANGLEFn(target, index, bufSize,
-                                                      length, data);
-}
-
-static void GL_BINDING_CALL Debug_glGetInteger64v(GLenum pname,
-                                                  GLint64* params) {
-  GL_SERVICE_LOG("glGetInteger64v"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetInteger64vFn != nullptr);
-  g_driver_gl.debug_fn.glGetInteger64vFn(pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetInteger64vRobustANGLE(GLenum pname,
-                                                             GLsizei bufSize,
-                                                             GLsizei* length,
-                                                             GLint64* data) {
-  GL_SERVICE_LOG("glGetInteger64vRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetInteger64vRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetInteger64vRobustANGLEFn(pname, bufSize, length,
-                                                    data);
-}
-
-static void GL_BINDING_CALL Debug_glGetIntegeri_v(GLenum target,
-                                                  GLuint index,
-                                                  GLint* data) {
-  GL_SERVICE_LOG("glGetIntegeri_v"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
-                 << ", " << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetIntegeri_vFn != nullptr);
-  g_driver_gl.debug_fn.glGetIntegeri_vFn(target, index, data);
-}
-
-static void GL_BINDING_CALL Debug_glGetIntegeri_vRobustANGLE(GLenum target,
-                                                             GLuint index,
-                                                             GLsizei bufSize,
-                                                             GLsizei* length,
-                                                             GLint* data) {
-  GL_SERVICE_LOG("glGetIntegeri_vRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetIntegeri_vRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetIntegeri_vRobustANGLEFn(target, index, bufSize,
-                                                    length, data);
-}
-
-static void GL_BINDING_CALL Debug_glGetIntegerv(GLenum pname, GLint* params) {
-  GL_SERVICE_LOG("glGetIntegerv"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetIntegervFn != nullptr);
-  g_driver_gl.debug_fn.glGetIntegervFn(pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetIntegervRobustANGLE(GLenum pname,
-                                                           GLsizei bufSize,
-                                                           GLsizei* length,
-                                                           GLint* data) {
-  GL_SERVICE_LOG("glGetIntegervRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetIntegervRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetIntegervRobustANGLEFn(pname, bufSize, length, data);
-}
-
-static void GL_BINDING_CALL Debug_glGetInternalformativ(GLenum target,
-                                                        GLenum internalformat,
-                                                        GLenum pname,
-                                                        GLsizei bufSize,
-                                                        GLint* params) {
-  GL_SERVICE_LOG("glGetInternalformativ"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(internalformat) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetInternalformativFn != nullptr);
-  g_driver_gl.debug_fn.glGetInternalformativFn(target, internalformat, pname,
-                                               bufSize, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetInternalformativRobustANGLE(GLenum target,
-                                       GLenum internalformat,
-                                       GLenum pname,
-                                       GLsizei bufSize,
-                                       GLsizei* length,
-                                       GLint* params) {
-  GL_SERVICE_LOG("glGetInternalformativRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(internalformat) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetInternalformativRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetInternalformativRobustANGLEFn(
-      target, internalformat, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetMultisamplefvRobustANGLE(GLenum pname,
-                                                                GLuint index,
-                                                                GLsizei bufSize,
-                                                                GLsizei* length,
-                                                                GLfloat* val) {
-  GL_SERVICE_LOG("glGetMultisamplefvRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << index
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(val) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetMultisamplefvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetMultisamplefvRobustANGLEFn(pname, index, bufSize,
-                                                       length, val);
-}
-
-static void GL_BINDING_CALL Debug_glGetnUniformfvRobustANGLE(GLuint program,
-                                                             GLint location,
-                                                             GLsizei bufSize,
-                                                             GLsizei* length,
-                                                             GLfloat* params) {
-  GL_SERVICE_LOG("glGetnUniformfvRobustANGLE"
-                 << "(" << program << ", " << location << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetnUniformfvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetnUniformfvRobustANGLEFn(program, location, bufSize,
-                                                    length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetnUniformivRobustANGLE(GLuint program,
-                                                             GLint location,
-                                                             GLsizei bufSize,
-                                                             GLsizei* length,
-                                                             GLint* params) {
-  GL_SERVICE_LOG("glGetnUniformivRobustANGLE"
-                 << "(" << program << ", " << location << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetnUniformivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetnUniformivRobustANGLEFn(program, location, bufSize,
-                                                    length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetnUniformuivRobustANGLE(GLuint program,
-                                                              GLint location,
-                                                              GLsizei bufSize,
-                                                              GLsizei* length,
-                                                              GLuint* params) {
-  GL_SERVICE_LOG("glGetnUniformuivRobustANGLE"
-                 << "(" << program << ", " << location << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetnUniformuivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetnUniformuivRobustANGLEFn(program, location, bufSize,
-                                                     length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetObjectLabel(GLenum identifier,
-                                                   GLuint name,
-                                                   GLsizei bufSize,
-                                                   GLsizei* length,
-                                                   char* label) {
-  GL_SERVICE_LOG("glGetObjectLabel"
-                 << "(" << GLEnums::GetStringEnum(identifier) << ", " << name
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(label) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetObjectLabelFn != nullptr);
-  g_driver_gl.debug_fn.glGetObjectLabelFn(identifier, name, bufSize, length,
-                                          label);
-}
-
-static void GL_BINDING_CALL Debug_glGetObjectPtrLabel(void* ptr,
-                                                      GLsizei bufSize,
-                                                      GLsizei* length,
-                                                      char* label) {
-  GL_SERVICE_LOG("glGetObjectPtrLabel"
-                 << "(" << static_cast<const void*>(ptr) << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(label) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetObjectPtrLabelFn != nullptr);
-  g_driver_gl.debug_fn.glGetObjectPtrLabelFn(ptr, bufSize, length, label);
-}
-
-static void GL_BINDING_CALL Debug_glGetPointerv(GLenum pname, void** params) {
-  GL_SERVICE_LOG("glGetPointerv"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << params
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetPointervFn != nullptr);
-  g_driver_gl.debug_fn.glGetPointervFn(pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetPointervRobustANGLERobustANGLE(GLenum pname,
-                                          GLsizei bufSize,
-                                          GLsizei* length,
-                                          void** params) {
-  GL_SERVICE_LOG("glGetPointervRobustANGLERobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", " << params
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetPointervRobustANGLERobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetPointervRobustANGLERobustANGLEFn(pname, bufSize,
-                                                             length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetProgramBinary(GLuint program,
-                                                     GLsizei bufSize,
-                                                     GLsizei* length,
-                                                     GLenum* binaryFormat,
-                                                     GLvoid* binary) {
-  GL_SERVICE_LOG("glGetProgramBinary"
-                 << "(" << program << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(binaryFormat) << ", "
-                 << static_cast<const void*>(binary) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramBinaryFn != nullptr);
-  g_driver_gl.debug_fn.glGetProgramBinaryFn(program, bufSize, length,
-                                            binaryFormat, binary);
-}
-
-static void GL_BINDING_CALL Debug_glGetProgramInfoLog(GLuint program,
-                                                      GLsizei bufsize,
-                                                      GLsizei* length,
-                                                      char* infolog) {
-  GL_SERVICE_LOG("glGetProgramInfoLog"
-                 << "(" << program << ", " << bufsize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(infolog) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramInfoLogFn != nullptr);
-  g_driver_gl.debug_fn.glGetProgramInfoLogFn(program, bufsize, length, infolog);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetProgramInterfaceiv(GLuint program,
-                              GLenum programInterface,
-                              GLenum pname,
-                              GLint* params) {
-  GL_SERVICE_LOG("glGetProgramInterfaceiv"
-                 << "(" << program << ", "
-                 << GLEnums::GetStringEnum(programInterface) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramInterfaceivFn != nullptr);
-  g_driver_gl.debug_fn.glGetProgramInterfaceivFn(program, programInterface,
-                                                 pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetProgramInterfaceivRobustANGLE(GLuint program,
-                                         GLenum programInterface,
-                                         GLenum pname,
-                                         GLsizei bufSize,
-                                         GLsizei* length,
-                                         GLint* params) {
-  GL_SERVICE_LOG("glGetProgramInterfaceivRobustANGLE"
-                 << "(" << program << ", "
-                 << GLEnums::GetStringEnum(programInterface) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramInterfaceivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetProgramInterfaceivRobustANGLEFn(
-      program, programInterface, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetProgramiv(GLuint program,
-                                                 GLenum pname,
-                                                 GLint* params) {
-  GL_SERVICE_LOG("glGetProgramiv"
-                 << "(" << program << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramivFn != nullptr);
-  g_driver_gl.debug_fn.glGetProgramivFn(program, pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetProgramivRobustANGLE(GLuint program,
-                                                            GLenum pname,
-                                                            GLsizei bufSize,
-                                                            GLsizei* length,
-                                                            GLint* params) {
-  GL_SERVICE_LOG("glGetProgramivRobustANGLE"
-                 << "(" << program << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetProgramivRobustANGLEFn(program, pname, bufSize,
-                                                   length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetProgramResourceiv(GLuint program,
-                             GLenum programInterface,
-                             GLuint index,
-                             GLsizei propCount,
-                             const GLenum* props,
-                             GLsizei bufSize,
-                             GLsizei* length,
-                             GLint* params) {
-  GL_SERVICE_LOG("glGetProgramResourceiv"
-                 << "(" << program << ", "
-                 << GLEnums::GetStringEnum(programInterface) << ", " << index
-                 << ", " << propCount << ", " << static_cast<const void*>(props)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramResourceivFn != nullptr);
-  g_driver_gl.debug_fn.glGetProgramResourceivFn(program, programInterface,
-                                                index, propCount, props,
-                                                bufSize, length, params);
-}
-
-static GLint GL_BINDING_CALL
-Debug_glGetProgramResourceLocation(GLuint program,
-                                   GLenum programInterface,
-                                   const char* name) {
-  GL_SERVICE_LOG("glGetProgramResourceLocation"
-                 << "(" << program << ", "
-                 << GLEnums::GetStringEnum(programInterface) << ", " << name
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramResourceLocationFn != nullptr);
-  GLint result = g_driver_gl.debug_fn.glGetProgramResourceLocationFn(
-      program, programInterface, name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL
-Debug_glGetProgramResourceName(GLuint program,
-                               GLenum programInterface,
-                               GLuint index,
-                               GLsizei bufSize,
-                               GLsizei* length,
-                               GLchar* name) {
-  GL_SERVICE_LOG("glGetProgramResourceName"
-                 << "(" << program << ", "
-                 << GLEnums::GetStringEnum(programInterface) << ", " << index
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(name) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetProgramResourceNameFn != nullptr);
-  g_driver_gl.debug_fn.glGetProgramResourceNameFn(program, programInterface,
-                                                  index, bufSize, length, name);
-}
-
-static void GL_BINDING_CALL Debug_glGetQueryiv(GLenum target,
-                                               GLenum pname,
-                                               GLint* params) {
-  GL_SERVICE_LOG("glGetQueryiv"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryivFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryivFn(target, pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetQueryivRobustANGLE(GLenum target,
-                                                          GLenum pname,
-                                                          GLsizei bufSize,
-                                                          GLsizei* length,
-                                                          GLint* params) {
-  GL_SERVICE_LOG("glGetQueryivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryivRobustANGLEFn(target, pname, bufSize, length,
-                                                 params);
-}
-
-static void GL_BINDING_CALL Debug_glGetQueryObjecti64v(GLuint id,
-                                                       GLenum pname,
-                                                       GLint64* params) {
-  GL_SERVICE_LOG("glGetQueryObjecti64v"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryObjecti64vFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryObjecti64vFn(id, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetQueryObjecti64vRobustANGLE(GLuint id,
-                                      GLenum pname,
-                                      GLsizei bufSize,
-                                      GLsizei* length,
-                                      GLint64* params) {
-  GL_SERVICE_LOG("glGetQueryObjecti64vRobustANGLE"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << bufSize << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryObjecti64vRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryObjecti64vRobustANGLEFn(id, pname, bufSize,
-                                                         length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetQueryObjectiv(GLuint id,
-                                                     GLenum pname,
-                                                     GLint* params) {
-  GL_SERVICE_LOG("glGetQueryObjectiv"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectivFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryObjectivFn(id, pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetQueryObjectivRobustANGLE(GLuint id,
-                                                                GLenum pname,
-                                                                GLsizei bufSize,
-                                                                GLsizei* length,
-                                                                GLint* params) {
-  GL_SERVICE_LOG("glGetQueryObjectivRobustANGLE"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << bufSize << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryObjectivRobustANGLEFn(id, pname, bufSize,
-                                                       length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetQueryObjectui64v(GLuint id,
-                                                        GLenum pname,
-                                                        GLuint64* params) {
-  GL_SERVICE_LOG("glGetQueryObjectui64v"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectui64vFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryObjectui64vFn(id, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetQueryObjectui64vRobustANGLE(GLuint id,
-                                       GLenum pname,
-                                       GLsizei bufSize,
-                                       GLsizei* length,
-                                       GLuint64* params) {
-  GL_SERVICE_LOG("glGetQueryObjectui64vRobustANGLE"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << bufSize << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectui64vRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryObjectui64vRobustANGLEFn(id, pname, bufSize,
-                                                          length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetQueryObjectuiv(GLuint id,
-                                                      GLenum pname,
-                                                      GLuint* params) {
-  GL_SERVICE_LOG("glGetQueryObjectuiv"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectuivFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryObjectuivFn(id, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetQueryObjectuivRobustANGLE(GLuint id,
-                                     GLenum pname,
-                                     GLsizei bufSize,
-                                     GLsizei* length,
-                                     GLuint* params) {
-  GL_SERVICE_LOG("glGetQueryObjectuivRobustANGLE"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << bufSize << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectuivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetQueryObjectuivRobustANGLEFn(id, pname, bufSize,
-                                                        length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetRenderbufferParameterivEXT(GLenum target,
-                                      GLenum pname,
-                                      GLint* params) {
-  GL_SERVICE_LOG("glGetRenderbufferParameterivEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetRenderbufferParameterivEXTFn != nullptr);
-  g_driver_gl.debug_fn.glGetRenderbufferParameterivEXTFn(target, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetRenderbufferParameterivRobustANGLE(GLenum target,
-                                              GLenum pname,
-                                              GLsizei bufSize,
-                                              GLsizei* length,
-                                              GLint* params) {
-  GL_SERVICE_LOG("glGetRenderbufferParameterivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetRenderbufferParameterivRobustANGLEFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glGetRenderbufferParameterivRobustANGLEFn(
-      target, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetSamplerParameterfv(GLuint sampler,
-                                                          GLenum pname,
-                                                          GLfloat* params) {
-  GL_SERVICE_LOG("glGetSamplerParameterfv"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetSamplerParameterfvFn != nullptr);
-  g_driver_gl.debug_fn.glGetSamplerParameterfvFn(sampler, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetSamplerParameterfvRobustANGLE(GLuint sampler,
-                                         GLenum pname,
-                                         GLsizei bufSize,
-                                         GLsizei* length,
-                                         GLfloat* params) {
-  GL_SERVICE_LOG("glGetSamplerParameterfvRobustANGLE"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetSamplerParameterfvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetSamplerParameterfvRobustANGLEFn(
-      sampler, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetSamplerParameterIivRobustANGLE(GLuint sampler,
-                                          GLenum pname,
-                                          GLsizei bufSize,
-                                          GLsizei* length,
-                                          GLint* params) {
-  GL_SERVICE_LOG("glGetSamplerParameterIivRobustANGLE"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetSamplerParameterIivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetSamplerParameterIivRobustANGLEFn(
-      sampler, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetSamplerParameterIuivRobustANGLE(GLuint sampler,
-                                           GLenum pname,
-                                           GLsizei bufSize,
-                                           GLsizei* length,
-                                           GLuint* params) {
-  GL_SERVICE_LOG("glGetSamplerParameterIuivRobustANGLE"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetSamplerParameterIuivRobustANGLEFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glGetSamplerParameterIuivRobustANGLEFn(
-      sampler, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetSamplerParameteriv(GLuint sampler,
-                                                          GLenum pname,
-                                                          GLint* params) {
-  GL_SERVICE_LOG("glGetSamplerParameteriv"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetSamplerParameterivFn != nullptr);
-  g_driver_gl.debug_fn.glGetSamplerParameterivFn(sampler, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetSamplerParameterivRobustANGLE(GLuint sampler,
-                                         GLenum pname,
-                                         GLsizei bufSize,
-                                         GLsizei* length,
-                                         GLint* params) {
-  GL_SERVICE_LOG("glGetSamplerParameterivRobustANGLE"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetSamplerParameterivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetSamplerParameterivRobustANGLEFn(
-      sampler, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetShaderInfoLog(GLuint shader,
-                                                     GLsizei bufsize,
-                                                     GLsizei* length,
-                                                     char* infolog) {
-  GL_SERVICE_LOG("glGetShaderInfoLog"
-                 << "(" << shader << ", " << bufsize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(infolog) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetShaderInfoLogFn != nullptr);
-  g_driver_gl.debug_fn.glGetShaderInfoLogFn(shader, bufsize, length, infolog);
-}
-
-static void GL_BINDING_CALL Debug_glGetShaderiv(GLuint shader,
-                                                GLenum pname,
-                                                GLint* params) {
-  GL_SERVICE_LOG("glGetShaderiv"
-                 << "(" << shader << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetShaderivFn != nullptr);
-  g_driver_gl.debug_fn.glGetShaderivFn(shader, pname, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetShaderivRobustANGLE(GLuint shader,
-                                                           GLenum pname,
-                                                           GLsizei bufSize,
-                                                           GLsizei* length,
-                                                           GLint* params) {
-  GL_SERVICE_LOG("glGetShaderivRobustANGLE"
-                 << "(" << shader << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetShaderivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetShaderivRobustANGLEFn(shader, pname, bufSize,
-                                                  length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetShaderPrecisionFormat(GLenum shadertype,
-                                 GLenum precisiontype,
-                                 GLint* range,
-                                 GLint* precision) {
-  GL_SERVICE_LOG("glGetShaderPrecisionFormat"
-                 << "(" << GLEnums::GetStringEnum(shadertype) << ", "
-                 << GLEnums::GetStringEnum(precisiontype) << ", "
-                 << static_cast<const void*>(range) << ", "
-                 << static_cast<const void*>(precision) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetShaderPrecisionFormatFn != nullptr);
-  g_driver_gl.debug_fn.glGetShaderPrecisionFormatFn(shadertype, precisiontype,
-                                                    range, precision);
-}
-
-static void GL_BINDING_CALL Debug_glGetShaderSource(GLuint shader,
-                                                    GLsizei bufsize,
-                                                    GLsizei* length,
-                                                    char* source) {
-  GL_SERVICE_LOG("glGetShaderSource"
-                 << "(" << shader << ", " << bufsize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(source) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetShaderSourceFn != nullptr);
-  g_driver_gl.debug_fn.glGetShaderSourceFn(shader, bufsize, length, source);
-}
-
-static const GLubyte* GL_BINDING_CALL Debug_glGetString(GLenum name) {
-  GL_SERVICE_LOG("glGetString"
-                 << "(" << GLEnums::GetStringEnum(name) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetStringFn != nullptr);
-  const GLubyte* result = g_driver_gl.debug_fn.glGetStringFn(name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static const GLubyte* GL_BINDING_CALL Debug_glGetStringi(GLenum name,
-                                                         GLuint index) {
-  GL_SERVICE_LOG("glGetStringi"
-                 << "(" << GLEnums::GetStringEnum(name) << ", " << index
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetStringiFn != nullptr);
-  const GLubyte* result = g_driver_gl.debug_fn.glGetStringiFn(name, index);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glGetSynciv(GLsync sync,
-                                              GLenum pname,
-                                              GLsizei bufSize,
-                                              GLsizei* length,
-                                              GLint* values) {
-  GL_SERVICE_LOG("glGetSynciv"
-                 << "(" << sync << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << bufSize << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(values) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetSyncivFn != nullptr);
-  g_driver_gl.debug_fn.glGetSyncivFn(sync, pname, bufSize, length, values);
-}
-
-static void GL_BINDING_CALL Debug_glGetTexLevelParameterfv(GLenum target,
-                                                           GLint level,
-                                                           GLenum pname,
-                                                           GLfloat* params) {
-  GL_SERVICE_LOG("glGetTexLevelParameterfv"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexLevelParameterfvFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexLevelParameterfvFn(target, level, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetTexLevelParameterfvRobustANGLE(GLenum target,
-                                          GLint level,
-                                          GLenum pname,
-                                          GLsizei bufSize,
-                                          GLsizei* length,
-                                          GLfloat* params) {
-  GL_SERVICE_LOG("glGetTexLevelParameterfvRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << GLEnums::GetStringEnum(pname) << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexLevelParameterfvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexLevelParameterfvRobustANGLEFn(
-      target, level, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetTexLevelParameteriv(GLenum target,
-                                                           GLint level,
-                                                           GLenum pname,
-                                                           GLint* params) {
-  GL_SERVICE_LOG("glGetTexLevelParameteriv"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexLevelParameterivFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexLevelParameterivFn(target, level, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetTexLevelParameterivRobustANGLE(GLenum target,
-                                          GLint level,
-                                          GLenum pname,
-                                          GLsizei bufSize,
-                                          GLsizei* length,
-                                          GLint* params) {
-  GL_SERVICE_LOG("glGetTexLevelParameterivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << GLEnums::GetStringEnum(pname) << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexLevelParameterivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexLevelParameterivRobustANGLEFn(
-      target, level, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetTexParameterfv(GLenum target,
-                                                      GLenum pname,
-                                                      GLfloat* params) {
-  GL_SERVICE_LOG("glGetTexParameterfv"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexParameterfvFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexParameterfvFn(target, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetTexParameterfvRobustANGLE(GLenum target,
-                                     GLenum pname,
-                                     GLsizei bufSize,
-                                     GLsizei* length,
-                                     GLfloat* params) {
-  GL_SERVICE_LOG("glGetTexParameterfvRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexParameterfvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexParameterfvRobustANGLEFn(target, pname, bufSize,
-                                                        length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetTexParameterIivRobustANGLE(GLenum target,
-                                      GLenum pname,
-                                      GLsizei bufSize,
-                                      GLsizei* length,
-                                      GLint* params) {
-  GL_SERVICE_LOG("glGetTexParameterIivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexParameterIivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexParameterIivRobustANGLEFn(target, pname, bufSize,
-                                                         length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetTexParameterIuivRobustANGLE(GLenum target,
-                                       GLenum pname,
-                                       GLsizei bufSize,
-                                       GLsizei* length,
-                                       GLuint* params) {
-  GL_SERVICE_LOG("glGetTexParameterIuivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexParameterIuivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexParameterIuivRobustANGLEFn(
-      target, pname, bufSize, length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetTexParameteriv(GLenum target,
-                                                      GLenum pname,
-                                                      GLint* params) {
-  GL_SERVICE_LOG("glGetTexParameteriv"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexParameterivFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexParameterivFn(target, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetTexParameterivRobustANGLE(GLenum target,
-                                     GLenum pname,
-                                     GLsizei bufSize,
-                                     GLsizei* length,
-                                     GLint* params) {
-  GL_SERVICE_LOG("glGetTexParameterivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTexParameterivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetTexParameterivRobustANGLEFn(target, pname, bufSize,
-                                                        length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetTransformFeedbackVarying(GLuint program,
-                                                                GLuint index,
-                                                                GLsizei bufSize,
-                                                                GLsizei* length,
-                                                                GLsizei* size,
-                                                                GLenum* type,
-                                                                char* name) {
-  GL_SERVICE_LOG("glGetTransformFeedbackVarying"
-                 << "(" << program << ", " << index << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(size) << ", "
-                 << static_cast<const void*>(type) << ", "
-                 << static_cast<const void*>(name) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTransformFeedbackVaryingFn != nullptr);
-  g_driver_gl.debug_fn.glGetTransformFeedbackVaryingFn(
-      program, index, bufSize, length, size, type, name);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetTranslatedShaderSourceANGLE(GLuint shader,
-                                       GLsizei bufsize,
-                                       GLsizei* length,
-                                       char* source) {
-  GL_SERVICE_LOG("glGetTranslatedShaderSourceANGLE"
-                 << "(" << shader << ", " << bufsize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(source) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetTranslatedShaderSourceANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetTranslatedShaderSourceANGLEFn(shader, bufsize,
-                                                          length, source);
-}
-
-static GLuint GL_BINDING_CALL
-Debug_glGetUniformBlockIndex(GLuint program, const char* uniformBlockName) {
-  GL_SERVICE_LOG("glGetUniformBlockIndex"
-                 << "(" << program << ", " << uniformBlockName << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformBlockIndexFn != nullptr);
-  GLuint result =
-      g_driver_gl.debug_fn.glGetUniformBlockIndexFn(program, uniformBlockName);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glGetUniformfv(GLuint program,
-                                                 GLint location,
-                                                 GLfloat* params) {
-  GL_SERVICE_LOG("glGetUniformfv"
-                 << "(" << program << ", " << location << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformfvFn != nullptr);
-  g_driver_gl.debug_fn.glGetUniformfvFn(program, location, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetUniformfvRobustANGLE(GLuint program,
-                                                            GLint location,
-                                                            GLsizei bufSize,
-                                                            GLsizei* length,
-                                                            GLfloat* params) {
-  GL_SERVICE_LOG("glGetUniformfvRobustANGLE"
-                 << "(" << program << ", " << location << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformfvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetUniformfvRobustANGLEFn(program, location, bufSize,
-                                                   length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetUniformIndices(GLuint program,
-                          GLsizei uniformCount,
-                          const char* const* uniformNames,
-                          GLuint* uniformIndices) {
-  GL_SERVICE_LOG("glGetUniformIndices"
-                 << "(" << program << ", " << uniformCount << ", "
-                 << static_cast<const void*>(uniformNames) << ", "
-                 << static_cast<const void*>(uniformIndices) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformIndicesFn != nullptr);
-  g_driver_gl.debug_fn.glGetUniformIndicesFn(program, uniformCount,
-                                             uniformNames, uniformIndices);
-}
-
-static void GL_BINDING_CALL Debug_glGetUniformiv(GLuint program,
-                                                 GLint location,
-                                                 GLint* params) {
-  GL_SERVICE_LOG("glGetUniformiv"
-                 << "(" << program << ", " << location << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformivFn != nullptr);
-  g_driver_gl.debug_fn.glGetUniformivFn(program, location, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetUniformivRobustANGLE(GLuint program,
-                                                            GLint location,
-                                                            GLsizei bufSize,
-                                                            GLsizei* length,
-                                                            GLint* params) {
-  GL_SERVICE_LOG("glGetUniformivRobustANGLE"
-                 << "(" << program << ", " << location << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetUniformivRobustANGLEFn(program, location, bufSize,
-                                                   length, params);
-}
-
-static GLint GL_BINDING_CALL Debug_glGetUniformLocation(GLuint program,
-                                                        const char* name) {
-  GL_SERVICE_LOG("glGetUniformLocation"
-                 << "(" << program << ", " << name << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformLocationFn != nullptr);
-  GLint result = g_driver_gl.debug_fn.glGetUniformLocationFn(program, name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glGetUniformuiv(GLuint program,
-                                                  GLint location,
-                                                  GLuint* params) {
-  GL_SERVICE_LOG("glGetUniformuiv"
-                 << "(" << program << ", " << location << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformuivFn != nullptr);
-  g_driver_gl.debug_fn.glGetUniformuivFn(program, location, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetUniformuivRobustANGLE(GLuint program,
-                                                             GLint location,
-                                                             GLsizei bufSize,
-                                                             GLsizei* length,
-                                                             GLuint* params) {
-  GL_SERVICE_LOG("glGetUniformuivRobustANGLE"
-                 << "(" << program << ", " << location << ", " << bufSize
-                 << ", " << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetUniformuivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetUniformuivRobustANGLEFn(program, location, bufSize,
-                                                    length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetVertexAttribfv(GLuint index,
-                                                      GLenum pname,
-                                                      GLfloat* params) {
-  GL_SERVICE_LOG("glGetVertexAttribfv"
-                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribfvFn != nullptr);
-  g_driver_gl.debug_fn.glGetVertexAttribfvFn(index, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetVertexAttribfvRobustANGLE(GLuint index,
-                                     GLenum pname,
-                                     GLsizei bufSize,
-                                     GLsizei* length,
-                                     GLfloat* params) {
-  GL_SERVICE_LOG("glGetVertexAttribfvRobustANGLE"
-                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribfvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetVertexAttribfvRobustANGLEFn(index, pname, bufSize,
-                                                        length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetVertexAttribIivRobustANGLE(GLuint index,
-                                      GLenum pname,
-                                      GLsizei bufSize,
-                                      GLsizei* length,
-                                      GLint* params) {
-  GL_SERVICE_LOG("glGetVertexAttribIivRobustANGLE"
-                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribIivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetVertexAttribIivRobustANGLEFn(index, pname, bufSize,
-                                                         length, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetVertexAttribIuivRobustANGLE(GLuint index,
-                                       GLenum pname,
-                                       GLsizei bufSize,
-                                       GLsizei* length,
-                                       GLuint* params) {
-  GL_SERVICE_LOG("glGetVertexAttribIuivRobustANGLE"
-                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribIuivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetVertexAttribIuivRobustANGLEFn(index, pname, bufSize,
-                                                          length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetVertexAttribiv(GLuint index,
-                                                      GLenum pname,
-                                                      GLint* params) {
-  GL_SERVICE_LOG("glGetVertexAttribiv"
-                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribivFn != nullptr);
-  g_driver_gl.debug_fn.glGetVertexAttribivFn(index, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetVertexAttribivRobustANGLE(GLuint index,
-                                     GLenum pname,
-                                     GLsizei bufSize,
-                                     GLsizei* length,
-                                     GLint* params) {
-  GL_SERVICE_LOG("glGetVertexAttribivRobustANGLE"
-                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glGetVertexAttribivRobustANGLEFn(index, pname, bufSize,
-                                                        length, params);
-}
-
-static void GL_BINDING_CALL Debug_glGetVertexAttribPointerv(GLuint index,
-                                                            GLenum pname,
-                                                            void** pointer) {
-  GL_SERVICE_LOG("glGetVertexAttribPointerv"
-                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << pointer << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribPointervFn != nullptr);
-  g_driver_gl.debug_fn.glGetVertexAttribPointervFn(index, pname, pointer);
-}
-
-static void GL_BINDING_CALL
-Debug_glGetVertexAttribPointervRobustANGLE(GLuint index,
-                                           GLenum pname,
-                                           GLsizei bufSize,
-                                           GLsizei* length,
-                                           void** pointer) {
-  GL_SERVICE_LOG("glGetVertexAttribPointervRobustANGLE"
-                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(length)
-                 << ", " << pointer << ")");
-  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribPointervRobustANGLEFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glGetVertexAttribPointervRobustANGLEFn(
-      index, pname, bufSize, length, pointer);
-}
-
-static void GL_BINDING_CALL Debug_glHint(GLenum target, GLenum mode) {
-  GL_SERVICE_LOG("glHint"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(mode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glHintFn != nullptr);
-  g_driver_gl.debug_fn.glHintFn(target, mode);
-}
-
-static void GL_BINDING_CALL Debug_glInsertEventMarkerEXT(GLsizei length,
-                                                         const char* marker) {
-  GL_SERVICE_LOG("glInsertEventMarkerEXT"
-                 << "(" << length << ", " << marker << ")");
-  DCHECK(g_driver_gl.debug_fn.glInsertEventMarkerEXTFn != nullptr);
-  g_driver_gl.debug_fn.glInsertEventMarkerEXTFn(length, marker);
-}
-
-static void GL_BINDING_CALL
-Debug_glInvalidateFramebuffer(GLenum target,
-                              GLsizei numAttachments,
-                              const GLenum* attachments) {
-  GL_SERVICE_LOG("glInvalidateFramebuffer"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << numAttachments << ", "
-                 << static_cast<const void*>(attachments) << ")");
-  DCHECK(g_driver_gl.debug_fn.glInvalidateFramebufferFn != nullptr);
-  g_driver_gl.debug_fn.glInvalidateFramebufferFn(target, numAttachments,
-                                                 attachments);
-}
-
-static void GL_BINDING_CALL
-Debug_glInvalidateSubFramebuffer(GLenum target,
-                                 GLsizei numAttachments,
-                                 const GLenum* attachments,
-                                 GLint x,
-                                 GLint y,
-                                 GLint width,
-                                 GLint height) {
-  GL_SERVICE_LOG("glInvalidateSubFramebuffer"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << numAttachments << ", "
-                 << static_cast<const void*>(attachments) << ", " << x << ", "
-                 << y << ", " << width << ", " << height << ")");
-  DCHECK(g_driver_gl.debug_fn.glInvalidateSubFramebufferFn != nullptr);
-  g_driver_gl.debug_fn.glInvalidateSubFramebufferFn(
-      target, numAttachments, attachments, x, y, width, height);
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsBuffer(GLuint buffer) {
-  GL_SERVICE_LOG("glIsBuffer"
-                 << "(" << buffer << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsBufferFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsBufferFn(buffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsEnabled(GLenum cap) {
-  GL_SERVICE_LOG("glIsEnabled"
-                 << "(" << GLEnums::GetStringEnum(cap) << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsEnabledFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsEnabledFn(cap);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsFenceAPPLE(GLuint fence) {
-  GL_SERVICE_LOG("glIsFenceAPPLE"
-                 << "(" << fence << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsFenceAPPLEFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsFenceAPPLEFn(fence);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsFenceNV(GLuint fence) {
-  GL_SERVICE_LOG("glIsFenceNV"
-                 << "(" << fence << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsFenceNVFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsFenceNVFn(fence);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsFramebufferEXT(GLuint framebuffer) {
-  GL_SERVICE_LOG("glIsFramebufferEXT"
-                 << "(" << framebuffer << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsFramebufferEXTFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsFramebufferEXTFn(framebuffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsPathNV(GLuint path) {
-  GL_SERVICE_LOG("glIsPathNV"
-                 << "(" << path << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsPathNVFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsPathNVFn(path);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsProgram(GLuint program) {
-  GL_SERVICE_LOG("glIsProgram"
-                 << "(" << program << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsProgramFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsProgramFn(program);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsQuery(GLuint query) {
-  GL_SERVICE_LOG("glIsQuery"
-                 << "(" << query << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsQueryFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsQueryFn(query);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL
-Debug_glIsRenderbufferEXT(GLuint renderbuffer) {
-  GL_SERVICE_LOG("glIsRenderbufferEXT"
-                 << "(" << renderbuffer << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsRenderbufferEXTFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsRenderbufferEXTFn(renderbuffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsSampler(GLuint sampler) {
-  GL_SERVICE_LOG("glIsSampler"
-                 << "(" << sampler << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsSamplerFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsSamplerFn(sampler);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsShader(GLuint shader) {
-  GL_SERVICE_LOG("glIsShader"
-                 << "(" << shader << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsShaderFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsShaderFn(shader);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsSync(GLsync sync) {
-  GL_SERVICE_LOG("glIsSync"
-                 << "(" << sync << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsSyncFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsSyncFn(sync);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsTexture(GLuint texture) {
-  GL_SERVICE_LOG("glIsTexture"
-                 << "(" << texture << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsTextureFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsTextureFn(texture);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsTransformFeedback(GLuint id) {
-  GL_SERVICE_LOG("glIsTransformFeedback"
-                 << "(" << id << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsTransformFeedbackFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsTransformFeedbackFn(id);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glIsVertexArrayOES(GLuint array) {
-  GL_SERVICE_LOG("glIsVertexArrayOES"
-                 << "(" << array << ")");
-  DCHECK(g_driver_gl.debug_fn.glIsVertexArrayOESFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glIsVertexArrayOESFn(array);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glLineWidth(GLfloat width) {
-  GL_SERVICE_LOG("glLineWidth"
-                 << "(" << width << ")");
-  DCHECK(g_driver_gl.debug_fn.glLineWidthFn != nullptr);
-  g_driver_gl.debug_fn.glLineWidthFn(width);
-}
-
-static void GL_BINDING_CALL Debug_glLinkProgram(GLuint program) {
-  GL_SERVICE_LOG("glLinkProgram"
-                 << "(" << program << ")");
-  DCHECK(g_driver_gl.debug_fn.glLinkProgramFn != nullptr);
-  g_driver_gl.debug_fn.glLinkProgramFn(program);
-}
-
-static void* GL_BINDING_CALL Debug_glMapBuffer(GLenum target, GLenum access) {
-  GL_SERVICE_LOG("glMapBuffer"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(access) << ")");
-  DCHECK(g_driver_gl.debug_fn.glMapBufferFn != nullptr);
-  void* result = g_driver_gl.debug_fn.glMapBufferFn(target, access);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void* GL_BINDING_CALL Debug_glMapBufferRange(GLenum target,
-                                                    GLintptr offset,
-                                                    GLsizeiptr length,
-                                                    GLbitfield access) {
-  GL_SERVICE_LOG("glMapBufferRange"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << offset
-                 << ", " << length << ", " << access << ")");
-  DCHECK(g_driver_gl.debug_fn.glMapBufferRangeFn != nullptr);
-  void* result =
-      g_driver_gl.debug_fn.glMapBufferRangeFn(target, offset, length, access);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glMatrixLoadfEXT(GLenum matrixMode,
-                                                   const GLfloat* m) {
-  GL_SERVICE_LOG("glMatrixLoadfEXT"
-                 << "(" << GLEnums::GetStringEnum(matrixMode) << ", "
-                 << static_cast<const void*>(m) << ")");
-  DCHECK(g_driver_gl.debug_fn.glMatrixLoadfEXTFn != nullptr);
-  g_driver_gl.debug_fn.glMatrixLoadfEXTFn(matrixMode, m);
-}
-
-static void GL_BINDING_CALL Debug_glMatrixLoadIdentityEXT(GLenum matrixMode) {
-  GL_SERVICE_LOG("glMatrixLoadIdentityEXT"
-                 << "(" << GLEnums::GetStringEnum(matrixMode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glMatrixLoadIdentityEXTFn != nullptr);
-  g_driver_gl.debug_fn.glMatrixLoadIdentityEXTFn(matrixMode);
-}
-
-static void GL_BINDING_CALL Debug_glMemoryBarrierEXT(GLbitfield barriers) {
-  GL_SERVICE_LOG("glMemoryBarrierEXT"
-                 << "(" << barriers << ")");
-  DCHECK(g_driver_gl.debug_fn.glMemoryBarrierEXTFn != nullptr);
-  g_driver_gl.debug_fn.glMemoryBarrierEXTFn(barriers);
-}
-
-static void GL_BINDING_CALL Debug_glObjectLabel(GLenum identifier,
-                                                GLuint name,
-                                                GLsizei length,
-                                                const char* label) {
-  GL_SERVICE_LOG("glObjectLabel"
-                 << "(" << GLEnums::GetStringEnum(identifier) << ", " << name
-                 << ", " << length << ", " << label << ")");
-  DCHECK(g_driver_gl.debug_fn.glObjectLabelFn != nullptr);
-  g_driver_gl.debug_fn.glObjectLabelFn(identifier, name, length, label);
-}
-
-static void GL_BINDING_CALL Debug_glObjectPtrLabel(void* ptr,
-                                                   GLsizei length,
-                                                   const char* label) {
-  GL_SERVICE_LOG("glObjectPtrLabel"
-                 << "(" << static_cast<const void*>(ptr) << ", " << length
-                 << ", " << label << ")");
-  DCHECK(g_driver_gl.debug_fn.glObjectPtrLabelFn != nullptr);
-  g_driver_gl.debug_fn.glObjectPtrLabelFn(ptr, length, label);
-}
-
-static void GL_BINDING_CALL Debug_glPathCommandsNV(GLuint path,
-                                                   GLsizei numCommands,
-                                                   const GLubyte* commands,
-                                                   GLsizei numCoords,
-                                                   GLenum coordType,
-                                                   const GLvoid* coords) {
-  GL_SERVICE_LOG("glPathCommandsNV"
-                 << "(" << path << ", " << numCommands << ", "
-                 << static_cast<const void*>(commands) << ", " << numCoords
-                 << ", " << GLEnums::GetStringEnum(coordType) << ", "
-                 << static_cast<const void*>(coords) << ")");
-  DCHECK(g_driver_gl.debug_fn.glPathCommandsNVFn != nullptr);
-  g_driver_gl.debug_fn.glPathCommandsNVFn(path, numCommands, commands,
-                                          numCoords, coordType, coords);
-}
-
-static void GL_BINDING_CALL Debug_glPathParameterfNV(GLuint path,
-                                                     GLenum pname,
-                                                     GLfloat value) {
-  GL_SERVICE_LOG("glPathParameterfNV"
-                 << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << value << ")");
-  DCHECK(g_driver_gl.debug_fn.glPathParameterfNVFn != nullptr);
-  g_driver_gl.debug_fn.glPathParameterfNVFn(path, pname, value);
-}
-
-static void GL_BINDING_CALL Debug_glPathParameteriNV(GLuint path,
-                                                     GLenum pname,
-                                                     GLint value) {
-  GL_SERVICE_LOG("glPathParameteriNV"
-                 << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
-                 << value << ")");
-  DCHECK(g_driver_gl.debug_fn.glPathParameteriNVFn != nullptr);
-  g_driver_gl.debug_fn.glPathParameteriNVFn(path, pname, value);
-}
-
-static void GL_BINDING_CALL Debug_glPathStencilFuncNV(GLenum func,
-                                                      GLint ref,
-                                                      GLuint mask) {
-  GL_SERVICE_LOG("glPathStencilFuncNV"
-                 << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
-                 << mask << ")");
-  DCHECK(g_driver_gl.debug_fn.glPathStencilFuncNVFn != nullptr);
-  g_driver_gl.debug_fn.glPathStencilFuncNVFn(func, ref, mask);
-}
-
-static void GL_BINDING_CALL Debug_glPauseTransformFeedback(void) {
-  GL_SERVICE_LOG("glPauseTransformFeedback"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glPauseTransformFeedbackFn != nullptr);
-  g_driver_gl.debug_fn.glPauseTransformFeedbackFn();
-}
-
-static void GL_BINDING_CALL Debug_glPixelStorei(GLenum pname, GLint param) {
-  GL_SERVICE_LOG("glPixelStorei"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << param
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glPixelStoreiFn != nullptr);
-  g_driver_gl.debug_fn.glPixelStoreiFn(pname, param);
-}
-
-static void GL_BINDING_CALL Debug_glPointParameteri(GLenum pname, GLint param) {
-  GL_SERVICE_LOG("glPointParameteri"
-                 << "(" << GLEnums::GetStringEnum(pname) << ", " << param
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glPointParameteriFn != nullptr);
-  g_driver_gl.debug_fn.glPointParameteriFn(pname, param);
-}
-
-static void GL_BINDING_CALL Debug_glPolygonOffset(GLfloat factor,
-                                                  GLfloat units) {
-  GL_SERVICE_LOG("glPolygonOffset"
-                 << "(" << factor << ", " << units << ")");
-  DCHECK(g_driver_gl.debug_fn.glPolygonOffsetFn != nullptr);
-  g_driver_gl.debug_fn.glPolygonOffsetFn(factor, units);
-}
-
-static void GL_BINDING_CALL Debug_glPopDebugGroup() {
-  GL_SERVICE_LOG("glPopDebugGroup"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glPopDebugGroupFn != nullptr);
-  g_driver_gl.debug_fn.glPopDebugGroupFn();
-}
-
-static void GL_BINDING_CALL Debug_glPopGroupMarkerEXT(void) {
-  GL_SERVICE_LOG("glPopGroupMarkerEXT"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glPopGroupMarkerEXTFn != nullptr);
-  g_driver_gl.debug_fn.glPopGroupMarkerEXTFn();
-}
-
-static void GL_BINDING_CALL Debug_glPrimitiveRestartIndex(GLuint index) {
-  GL_SERVICE_LOG("glPrimitiveRestartIndex"
-                 << "(" << index << ")");
-  DCHECK(g_driver_gl.debug_fn.glPrimitiveRestartIndexFn != nullptr);
-  g_driver_gl.debug_fn.glPrimitiveRestartIndexFn(index);
-}
-
-static void GL_BINDING_CALL Debug_glProgramBinary(GLuint program,
-                                                  GLenum binaryFormat,
-                                                  const GLvoid* binary,
-                                                  GLsizei length) {
-  GL_SERVICE_LOG("glProgramBinary"
-                 << "(" << program << ", "
-                 << GLEnums::GetStringEnum(binaryFormat) << ", "
-                 << static_cast<const void*>(binary) << ", " << length << ")");
-  DCHECK(g_driver_gl.debug_fn.glProgramBinaryFn != nullptr);
-  g_driver_gl.debug_fn.glProgramBinaryFn(program, binaryFormat, binary, length);
-}
-
-static void GL_BINDING_CALL Debug_glProgramParameteri(GLuint program,
-                                                      GLenum pname,
-                                                      GLint value) {
-  GL_SERVICE_LOG("glProgramParameteri"
-                 << "(" << program << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << value << ")");
-  DCHECK(g_driver_gl.debug_fn.glProgramParameteriFn != nullptr);
-  g_driver_gl.debug_fn.glProgramParameteriFn(program, pname, value);
-}
-
-static void GL_BINDING_CALL
-Debug_glProgramPathFragmentInputGenNV(GLuint program,
-                                      GLint location,
-                                      GLenum genMode,
-                                      GLint components,
-                                      const GLfloat* coeffs) {
-  GL_SERVICE_LOG("glProgramPathFragmentInputGenNV"
-                 << "(" << program << ", " << location << ", "
-                 << GLEnums::GetStringEnum(genMode) << ", " << components
-                 << ", " << static_cast<const void*>(coeffs) << ")");
-  DCHECK(g_driver_gl.debug_fn.glProgramPathFragmentInputGenNVFn != nullptr);
-  g_driver_gl.debug_fn.glProgramPathFragmentInputGenNVFn(
-      program, location, genMode, components, coeffs);
-}
-
-static void GL_BINDING_CALL Debug_glPushDebugGroup(GLenum source,
-                                                   GLuint id,
-                                                   GLsizei length,
-                                                   const char* message) {
-  GL_SERVICE_LOG("glPushDebugGroup"
-                 << "(" << GLEnums::GetStringEnum(source) << ", " << id << ", "
-                 << length << ", " << message << ")");
-  DCHECK(g_driver_gl.debug_fn.glPushDebugGroupFn != nullptr);
-  g_driver_gl.debug_fn.glPushDebugGroupFn(source, id, length, message);
-}
-
-static void GL_BINDING_CALL Debug_glPushGroupMarkerEXT(GLsizei length,
-                                                       const char* marker) {
-  GL_SERVICE_LOG("glPushGroupMarkerEXT"
-                 << "(" << length << ", " << marker << ")");
-  DCHECK(g_driver_gl.debug_fn.glPushGroupMarkerEXTFn != nullptr);
-  g_driver_gl.debug_fn.glPushGroupMarkerEXTFn(length, marker);
-}
-
-static void GL_BINDING_CALL Debug_glQueryCounter(GLuint id, GLenum target) {
-  GL_SERVICE_LOG("glQueryCounter"
-                 << "(" << id << ", " << GLEnums::GetStringEnum(target) << ")");
-  DCHECK(g_driver_gl.debug_fn.glQueryCounterFn != nullptr);
-  g_driver_gl.debug_fn.glQueryCounterFn(id, target);
-}
-
-static void GL_BINDING_CALL Debug_glReadBuffer(GLenum src) {
-  GL_SERVICE_LOG("glReadBuffer"
-                 << "(" << GLEnums::GetStringEnum(src) << ")");
-  DCHECK(g_driver_gl.debug_fn.glReadBufferFn != nullptr);
-  g_driver_gl.debug_fn.glReadBufferFn(src);
-}
-
-static void GL_BINDING_CALL Debug_glReadnPixelsRobustANGLE(GLint x,
-                                                           GLint y,
-                                                           GLsizei width,
-                                                           GLsizei height,
-                                                           GLenum format,
-                                                           GLenum type,
-                                                           GLsizei bufSize,
-                                                           GLsizei* length,
-                                                           void* data) {
-  GL_SERVICE_LOG("glReadnPixelsRobustANGLE"
-                 << "(" << x << ", " << y << ", " << width << ", " << height
-                 << ", " << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(data) << ")");
-  DCHECK(g_driver_gl.debug_fn.glReadnPixelsRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glReadnPixelsRobustANGLEFn(x, y, width, height, format,
-                                                  type, bufSize, length, data);
-}
-
-static void GL_BINDING_CALL Debug_glReadPixels(GLint x,
-                                               GLint y,
-                                               GLsizei width,
-                                               GLsizei height,
-                                               GLenum format,
-                                               GLenum type,
-                                               void* pixels) {
-  GL_SERVICE_LOG("glReadPixels"
-                 << "(" << x << ", " << y << ", " << width << ", " << height
-                 << ", " << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glReadPixelsFn != nullptr);
-  g_driver_gl.debug_fn.glReadPixelsFn(x, y, width, height, format, type,
-                                      pixels);
-}
-
-static void GL_BINDING_CALL Debug_glReadPixelsRobustANGLE(GLint x,
-                                                          GLint y,
-                                                          GLsizei width,
-                                                          GLsizei height,
-                                                          GLenum format,
-                                                          GLenum type,
-                                                          GLsizei bufSize,
-                                                          GLsizei* length,
-                                                          void* pixels) {
-  GL_SERVICE_LOG("glReadPixelsRobustANGLE"
-                 << "(" << x << ", " << y << ", " << width << ", " << height
-                 << ", " << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
-                 << static_cast<const void*>(length) << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glReadPixelsRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glReadPixelsRobustANGLEFn(x, y, width, height, format,
-                                                 type, bufSize, length, pixels);
-}
-
-static void GL_BINDING_CALL Debug_glReleaseShaderCompiler(void) {
-  GL_SERVICE_LOG("glReleaseShaderCompiler"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glReleaseShaderCompilerFn != nullptr);
-  g_driver_gl.debug_fn.glReleaseShaderCompilerFn();
-}
-
-static void GL_BINDING_CALL
-Debug_glRenderbufferStorageEXT(GLenum target,
-                               GLenum internalformat,
-                               GLsizei width,
-                               GLsizei height) {
-  GL_SERVICE_LOG("glRenderbufferStorageEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(internalformat) << ", " << width
-                 << ", " << height << ")");
-  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageEXTFn != nullptr);
-  g_driver_gl.debug_fn.glRenderbufferStorageEXTFn(target, internalformat, width,
-                                                  height);
-}
-
-static void GL_BINDING_CALL
-Debug_glRenderbufferStorageMultisample(GLenum target,
-                                       GLsizei samples,
-                                       GLenum internalformat,
-                                       GLsizei width,
-                                       GLsizei height) {
-  GL_SERVICE_LOG("glRenderbufferStorageMultisample"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << samples
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
-                 << width << ", " << height << ")");
-  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageMultisampleFn != nullptr);
-  g_driver_gl.debug_fn.glRenderbufferStorageMultisampleFn(
-      target, samples, internalformat, width, height);
-}
-
-static void GL_BINDING_CALL
-Debug_glRenderbufferStorageMultisampleANGLE(GLenum target,
-                                            GLsizei samples,
-                                            GLenum internalformat,
-                                            GLsizei width,
-                                            GLsizei height) {
-  GL_SERVICE_LOG("glRenderbufferStorageMultisampleANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << samples
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
-                 << width << ", " << height << ")");
-  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageMultisampleANGLEFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glRenderbufferStorageMultisampleANGLEFn(
-      target, samples, internalformat, width, height);
-}
-
-static void GL_BINDING_CALL
-Debug_glRenderbufferStorageMultisampleEXT(GLenum target,
-                                          GLsizei samples,
-                                          GLenum internalformat,
-                                          GLsizei width,
-                                          GLsizei height) {
-  GL_SERVICE_LOG("glRenderbufferStorageMultisampleEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << samples
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
-                 << width << ", " << height << ")");
-  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageMultisampleEXTFn != nullptr);
-  g_driver_gl.debug_fn.glRenderbufferStorageMultisampleEXTFn(
-      target, samples, internalformat, width, height);
-}
-
-static void GL_BINDING_CALL
-Debug_glRenderbufferStorageMultisampleIMG(GLenum target,
-                                          GLsizei samples,
-                                          GLenum internalformat,
-                                          GLsizei width,
-                                          GLsizei height) {
-  GL_SERVICE_LOG("glRenderbufferStorageMultisampleIMG"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << samples
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
-                 << width << ", " << height << ")");
-  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageMultisampleIMGFn != nullptr);
-  g_driver_gl.debug_fn.glRenderbufferStorageMultisampleIMGFn(
-      target, samples, internalformat, width, height);
-}
-
-static void GL_BINDING_CALL Debug_glResumeTransformFeedback(void) {
-  GL_SERVICE_LOG("glResumeTransformFeedback"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glResumeTransformFeedbackFn != nullptr);
-  g_driver_gl.debug_fn.glResumeTransformFeedbackFn();
-}
-
-static void GL_BINDING_CALL Debug_glSampleCoverage(GLclampf value,
-                                                   GLboolean invert) {
-  GL_SERVICE_LOG("glSampleCoverage"
-                 << "(" << value << ", " << GLEnums::GetStringBool(invert)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glSampleCoverageFn != nullptr);
-  g_driver_gl.debug_fn.glSampleCoverageFn(value, invert);
-}
-
-static void GL_BINDING_CALL Debug_glSamplerParameterf(GLuint sampler,
-                                                      GLenum pname,
-                                                      GLfloat param) {
-  GL_SERVICE_LOG("glSamplerParameterf"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << param << ")");
-  DCHECK(g_driver_gl.debug_fn.glSamplerParameterfFn != nullptr);
-  g_driver_gl.debug_fn.glSamplerParameterfFn(sampler, pname, param);
-}
-
-static void GL_BINDING_CALL Debug_glSamplerParameterfv(GLuint sampler,
-                                                       GLenum pname,
-                                                       const GLfloat* params) {
-  GL_SERVICE_LOG("glSamplerParameterfv"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glSamplerParameterfvFn != nullptr);
-  g_driver_gl.debug_fn.glSamplerParameterfvFn(sampler, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glSamplerParameterfvRobustANGLE(GLuint sampler,
-                                      GLenum pname,
-                                      GLsizei bufSize,
-                                      const GLfloat* param) {
-  GL_SERVICE_LOG("glSamplerParameterfvRobustANGLE"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(param)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glSamplerParameterfvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glSamplerParameterfvRobustANGLEFn(sampler, pname,
-                                                         bufSize, param);
-}
-
-static void GL_BINDING_CALL Debug_glSamplerParameteri(GLuint sampler,
-                                                      GLenum pname,
-                                                      GLint param) {
-  GL_SERVICE_LOG("glSamplerParameteri"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << param << ")");
-  DCHECK(g_driver_gl.debug_fn.glSamplerParameteriFn != nullptr);
-  g_driver_gl.debug_fn.glSamplerParameteriFn(sampler, pname, param);
-}
-
-static void GL_BINDING_CALL
-Debug_glSamplerParameterIivRobustANGLE(GLuint sampler,
-                                       GLenum pname,
-                                       GLsizei bufSize,
-                                       const GLint* param) {
-  GL_SERVICE_LOG("glSamplerParameterIivRobustANGLE"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(param)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glSamplerParameterIivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glSamplerParameterIivRobustANGLEFn(sampler, pname,
-                                                          bufSize, param);
-}
-
-static void GL_BINDING_CALL
-Debug_glSamplerParameterIuivRobustANGLE(GLuint sampler,
-                                        GLenum pname,
-                                        GLsizei bufSize,
-                                        const GLuint* param) {
-  GL_SERVICE_LOG("glSamplerParameterIuivRobustANGLE"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(param)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glSamplerParameterIuivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glSamplerParameterIuivRobustANGLEFn(sampler, pname,
-                                                           bufSize, param);
-}
-
-static void GL_BINDING_CALL Debug_glSamplerParameteriv(GLuint sampler,
-                                                       GLenum pname,
-                                                       const GLint* params) {
-  GL_SERVICE_LOG("glSamplerParameteriv"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glSamplerParameterivFn != nullptr);
-  g_driver_gl.debug_fn.glSamplerParameterivFn(sampler, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glSamplerParameterivRobustANGLE(GLuint sampler,
-                                      GLenum pname,
-                                      GLsizei bufSize,
-                                      const GLint* param) {
-  GL_SERVICE_LOG("glSamplerParameterivRobustANGLE"
-                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
-                 << ", " << bufSize << ", " << static_cast<const void*>(param)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glSamplerParameterivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glSamplerParameterivRobustANGLEFn(sampler, pname,
-                                                         bufSize, param);
-}
-
-static void GL_BINDING_CALL Debug_glScissor(GLint x,
-                                            GLint y,
-                                            GLsizei width,
-                                            GLsizei height) {
-  GL_SERVICE_LOG("glScissor"
-                 << "(" << x << ", " << y << ", " << width << ", " << height
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glScissorFn != nullptr);
-  g_driver_gl.debug_fn.glScissorFn(x, y, width, height);
-}
-
-static void GL_BINDING_CALL Debug_glSetFenceAPPLE(GLuint fence) {
-  GL_SERVICE_LOG("glSetFenceAPPLE"
-                 << "(" << fence << ")");
-  DCHECK(g_driver_gl.debug_fn.glSetFenceAPPLEFn != nullptr);
-  g_driver_gl.debug_fn.glSetFenceAPPLEFn(fence);
-}
-
-static void GL_BINDING_CALL Debug_glSetFenceNV(GLuint fence, GLenum condition) {
-  GL_SERVICE_LOG("glSetFenceNV"
-                 << "(" << fence << ", " << GLEnums::GetStringEnum(condition)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glSetFenceNVFn != nullptr);
-  g_driver_gl.debug_fn.glSetFenceNVFn(fence, condition);
-}
-
-static void GL_BINDING_CALL Debug_glShaderBinary(GLsizei n,
-                                                 const GLuint* shaders,
-                                                 GLenum binaryformat,
-                                                 const void* binary,
-                                                 GLsizei length) {
-  GL_SERVICE_LOG("glShaderBinary"
-                 << "(" << n << ", " << static_cast<const void*>(shaders)
-                 << ", " << GLEnums::GetStringEnum(binaryformat) << ", "
-                 << static_cast<const void*>(binary) << ", " << length << ")");
-  DCHECK(g_driver_gl.debug_fn.glShaderBinaryFn != nullptr);
-  g_driver_gl.debug_fn.glShaderBinaryFn(n, shaders, binaryformat, binary,
-                                        length);
-}
-
-static void GL_BINDING_CALL Debug_glShaderSource(GLuint shader,
-                                                 GLsizei count,
-                                                 const char* const* str,
-                                                 const GLint* length) {
-  GL_SERVICE_LOG("glShaderSource"
-                 << "(" << shader << ", " << count << ", "
-                 << static_cast<const void*>(str) << ", "
-                 << static_cast<const void*>(length) << ")");
-  DCHECK(g_driver_gl.debug_fn.glShaderSourceFn != nullptr);
-  g_driver_gl.debug_fn.glShaderSourceFn(shader, count, str, length);
-
-  GL_SERVICE_LOG_CODE_BLOCK({
-    for (GLsizei ii = 0; ii < count; ++ii) {
-      if (str[ii]) {
-        if (length && length[ii] >= 0) {
-          std::string source(str[ii], length[ii]);
-          GL_SERVICE_LOG("  " << ii << ": ---\n" << source << "\n---");
-        } else {
-          GL_SERVICE_LOG("  " << ii << ": ---\n" << str[ii] << "\n---");
-        }
-      } else {
-        GL_SERVICE_LOG("  " << ii << ": NULL");
-      }
-    }
-  });
-}
-
-static void GL_BINDING_CALL
-Debug_glStencilFillPathInstancedNV(GLsizei numPaths,
-                                   GLenum pathNameType,
-                                   const void* paths,
-                                   GLuint pathBase,
-                                   GLenum fillMode,
-                                   GLuint mask,
-                                   GLenum transformType,
-                                   const GLfloat* transformValues) {
-  GL_SERVICE_LOG("glStencilFillPathInstancedNV"
-                 << "(" << numPaths << ", "
-                 << GLEnums::GetStringEnum(pathNameType) << ", "
-                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
-                 << GLEnums::GetStringEnum(fillMode) << ", " << mask << ", "
-                 << GLEnums::GetStringEnum(transformType) << ", "
-                 << static_cast<const void*>(transformValues) << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilFillPathInstancedNVFn != nullptr);
-  g_driver_gl.debug_fn.glStencilFillPathInstancedNVFn(
-      numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType,
-      transformValues);
-}
-
-static void GL_BINDING_CALL Debug_glStencilFillPathNV(GLuint path,
-                                                      GLenum fillMode,
-                                                      GLuint mask) {
-  GL_SERVICE_LOG("glStencilFillPathNV"
-                 << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
-                 << ", " << mask << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilFillPathNVFn != nullptr);
-  g_driver_gl.debug_fn.glStencilFillPathNVFn(path, fillMode, mask);
-}
-
-static void GL_BINDING_CALL Debug_glStencilFunc(GLenum func,
-                                                GLint ref,
-                                                GLuint mask) {
-  GL_SERVICE_LOG("glStencilFunc"
-                 << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
-                 << mask << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilFuncFn != nullptr);
-  g_driver_gl.debug_fn.glStencilFuncFn(func, ref, mask);
-}
-
-static void GL_BINDING_CALL Debug_glStencilFuncSeparate(GLenum face,
-                                                        GLenum func,
-                                                        GLint ref,
-                                                        GLuint mask) {
-  GL_SERVICE_LOG("glStencilFuncSeparate"
-                 << "(" << GLEnums::GetStringEnum(face) << ", "
-                 << GLEnums::GetStringEnum(func) << ", " << ref << ", " << mask
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilFuncSeparateFn != nullptr);
-  g_driver_gl.debug_fn.glStencilFuncSeparateFn(face, func, ref, mask);
-}
-
-static void GL_BINDING_CALL Debug_glStencilMask(GLuint mask) {
-  GL_SERVICE_LOG("glStencilMask"
-                 << "(" << mask << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilMaskFn != nullptr);
-  g_driver_gl.debug_fn.glStencilMaskFn(mask);
-}
-
-static void GL_BINDING_CALL Debug_glStencilMaskSeparate(GLenum face,
-                                                        GLuint mask) {
-  GL_SERVICE_LOG("glStencilMaskSeparate"
-                 << "(" << GLEnums::GetStringEnum(face) << ", " << mask << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilMaskSeparateFn != nullptr);
-  g_driver_gl.debug_fn.glStencilMaskSeparateFn(face, mask);
-}
-
-static void GL_BINDING_CALL Debug_glStencilOp(GLenum fail,
-                                              GLenum zfail,
-                                              GLenum zpass) {
-  GL_SERVICE_LOG("glStencilOp"
-                 << "(" << GLEnums::GetStringEnum(fail) << ", "
-                 << GLEnums::GetStringEnum(zfail) << ", "
-                 << GLEnums::GetStringEnum(zpass) << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilOpFn != nullptr);
-  g_driver_gl.debug_fn.glStencilOpFn(fail, zfail, zpass);
-}
-
-static void GL_BINDING_CALL Debug_glStencilOpSeparate(GLenum face,
-                                                      GLenum fail,
-                                                      GLenum zfail,
-                                                      GLenum zpass) {
-  GL_SERVICE_LOG("glStencilOpSeparate"
-                 << "(" << GLEnums::GetStringEnum(face) << ", "
-                 << GLEnums::GetStringEnum(fail) << ", "
-                 << GLEnums::GetStringEnum(zfail) << ", "
-                 << GLEnums::GetStringEnum(zpass) << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilOpSeparateFn != nullptr);
-  g_driver_gl.debug_fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
-}
-
-static void GL_BINDING_CALL
-Debug_glStencilStrokePathInstancedNV(GLsizei numPaths,
-                                     GLenum pathNameType,
-                                     const void* paths,
-                                     GLuint pathBase,
-                                     GLint ref,
-                                     GLuint mask,
-                                     GLenum transformType,
-                                     const GLfloat* transformValues) {
-  GL_SERVICE_LOG(
-      "glStencilStrokePathInstancedNV"
-      << "(" << numPaths << ", " << GLEnums::GetStringEnum(pathNameType) << ", "
-      << static_cast<const void*>(paths) << ", " << pathBase << ", " << ref
-      << ", " << mask << ", " << GLEnums::GetStringEnum(transformType) << ", "
-      << static_cast<const void*>(transformValues) << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilStrokePathInstancedNVFn != nullptr);
-  g_driver_gl.debug_fn.glStencilStrokePathInstancedNVFn(
-      numPaths, pathNameType, paths, pathBase, ref, mask, transformType,
-      transformValues);
-}
-
-static void GL_BINDING_CALL Debug_glStencilStrokePathNV(GLuint path,
-                                                        GLint reference,
-                                                        GLuint mask) {
-  GL_SERVICE_LOG("glStencilStrokePathNV"
-                 << "(" << path << ", " << reference << ", " << mask << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilStrokePathNVFn != nullptr);
-  g_driver_gl.debug_fn.glStencilStrokePathNVFn(path, reference, mask);
-}
-
-static void GL_BINDING_CALL
-Debug_glStencilThenCoverFillPathInstancedNV(GLsizei numPaths,
-                                            GLenum pathNameType,
-                                            const void* paths,
-                                            GLuint pathBase,
-                                            GLenum fillMode,
-                                            GLuint mask,
-                                            GLenum coverMode,
-                                            GLenum transformType,
-                                            const GLfloat* transformValues) {
-  GL_SERVICE_LOG("glStencilThenCoverFillPathInstancedNV"
-                 << "(" << numPaths << ", "
-                 << GLEnums::GetStringEnum(pathNameType) << ", "
-                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
-                 << GLEnums::GetStringEnum(fillMode) << ", " << mask << ", "
-                 << GLEnums::GetStringEnum(coverMode) << ", "
-                 << GLEnums::GetStringEnum(transformType) << ", "
-                 << static_cast<const void*>(transformValues) << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilThenCoverFillPathInstancedNVFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glStencilThenCoverFillPathInstancedNVFn(
-      numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
-      transformType, transformValues);
-}
-
-static void GL_BINDING_CALL
-Debug_glStencilThenCoverFillPathNV(GLuint path,
-                                   GLenum fillMode,
-                                   GLuint mask,
-                                   GLenum coverMode) {
-  GL_SERVICE_LOG("glStencilThenCoverFillPathNV"
-                 << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
-                 << ", " << mask << ", " << GLEnums::GetStringEnum(coverMode)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilThenCoverFillPathNVFn != nullptr);
-  g_driver_gl.debug_fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask,
-                                                      coverMode);
-}
-
-static void GL_BINDING_CALL
-Debug_glStencilThenCoverStrokePathInstancedNV(GLsizei numPaths,
-                                              GLenum pathNameType,
-                                              const void* paths,
-                                              GLuint pathBase,
-                                              GLint ref,
-                                              GLuint mask,
-                                              GLenum coverMode,
-                                              GLenum transformType,
-                                              const GLfloat* transformValues) {
-  GL_SERVICE_LOG(
-      "glStencilThenCoverStrokePathInstancedNV"
-      << "(" << numPaths << ", " << GLEnums::GetStringEnum(pathNameType) << ", "
-      << static_cast<const void*>(paths) << ", " << pathBase << ", " << ref
-      << ", " << mask << ", " << GLEnums::GetStringEnum(coverMode) << ", "
-      << GLEnums::GetStringEnum(transformType) << ", "
-      << static_cast<const void*>(transformValues) << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilThenCoverStrokePathInstancedNVFn !=
-         nullptr);
-  g_driver_gl.debug_fn.glStencilThenCoverStrokePathInstancedNVFn(
-      numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
-      transformType, transformValues);
-}
-
-static void GL_BINDING_CALL
-Debug_glStencilThenCoverStrokePathNV(GLuint path,
-                                     GLint reference,
-                                     GLuint mask,
-                                     GLenum coverMode) {
-  GL_SERVICE_LOG("glStencilThenCoverStrokePathNV"
-                 << "(" << path << ", " << reference << ", " << mask << ", "
-                 << GLEnums::GetStringEnum(coverMode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glStencilThenCoverStrokePathNVFn != nullptr);
-  g_driver_gl.debug_fn.glStencilThenCoverStrokePathNVFn(path, reference, mask,
-                                                        coverMode);
-}
-
-static GLboolean GL_BINDING_CALL Debug_glTestFenceAPPLE(GLuint fence) {
-  GL_SERVICE_LOG("glTestFenceAPPLE"
-                 << "(" << fence << ")");
-  DCHECK(g_driver_gl.debug_fn.glTestFenceAPPLEFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glTestFenceAPPLEFn(fence);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_glTestFenceNV(GLuint fence) {
-  GL_SERVICE_LOG("glTestFenceNV"
-                 << "(" << fence << ")");
-  DCHECK(g_driver_gl.debug_fn.glTestFenceNVFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glTestFenceNVFn(fence);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glTexImage2D(GLenum target,
-                                               GLint level,
-                                               GLint internalformat,
-                                               GLsizei width,
-                                               GLsizei height,
-                                               GLint border,
-                                               GLenum format,
-                                               GLenum type,
-                                               const void* pixels) {
-  GL_SERVICE_LOG("glTexImage2D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << internalformat << ", " << width << ", " << height
-                 << ", " << border << ", " << GLEnums::GetStringEnum(format)
-                 << ", " << GLEnums::GetStringEnum(type) << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexImage2DFn != nullptr);
-  g_driver_gl.debug_fn.glTexImage2DFn(target, level, internalformat, width,
-                                      height, border, format, type, pixels);
-}
-
-static void GL_BINDING_CALL Debug_glTexImage2DRobustANGLE(GLenum target,
-                                                          GLint level,
-                                                          GLint internalformat,
-                                                          GLsizei width,
-                                                          GLsizei height,
-                                                          GLint border,
-                                                          GLenum format,
-                                                          GLenum type,
-                                                          GLsizei bufSize,
-                                                          const void* pixels) {
-  GL_SERVICE_LOG("glTexImage2DRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << internalformat << ", " << width << ", " << height
-                 << ", " << border << ", " << GLEnums::GetStringEnum(format)
-                 << ", " << GLEnums::GetStringEnum(type) << ", " << bufSize
-                 << ", " << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexImage2DRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glTexImage2DRobustANGLEFn(target, level, internalformat,
-                                                 width, height, border, format,
-                                                 type, bufSize, pixels);
-}
-
-static void GL_BINDING_CALL Debug_glTexImage3D(GLenum target,
-                                               GLint level,
-                                               GLint internalformat,
-                                               GLsizei width,
-                                               GLsizei height,
-                                               GLsizei depth,
-                                               GLint border,
-                                               GLenum format,
-                                               GLenum type,
-                                               const void* pixels) {
-  GL_SERVICE_LOG("glTexImage3D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << internalformat << ", " << width << ", " << height
-                 << ", " << depth << ", " << border << ", "
-                 << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexImage3DFn != nullptr);
-  g_driver_gl.debug_fn.glTexImage3DFn(target, level, internalformat, width,
-                                      height, depth, border, format, type,
-                                      pixels);
-}
-
-static void GL_BINDING_CALL Debug_glTexImage3DRobustANGLE(GLenum target,
-                                                          GLint level,
-                                                          GLint internalformat,
-                                                          GLsizei width,
-                                                          GLsizei height,
-                                                          GLsizei depth,
-                                                          GLint border,
-                                                          GLenum format,
-                                                          GLenum type,
-                                                          GLsizei bufSize,
-                                                          const void* pixels) {
-  GL_SERVICE_LOG("glTexImage3DRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << internalformat << ", " << width << ", " << height
-                 << ", " << depth << ", " << border << ", "
-                 << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexImage3DRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glTexImage3DRobustANGLEFn(target, level, internalformat,
-                                                 width, height, depth, border,
-                                                 format, type, bufSize, pixels);
-}
-
-static void GL_BINDING_CALL Debug_glTexParameterf(GLenum target,
-                                                  GLenum pname,
-                                                  GLfloat param) {
-  GL_SERVICE_LOG("glTexParameterf"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << param << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexParameterfFn != nullptr);
-  g_driver_gl.debug_fn.glTexParameterfFn(target, pname, param);
-}
-
-static void GL_BINDING_CALL Debug_glTexParameterfv(GLenum target,
-                                                   GLenum pname,
-                                                   const GLfloat* params) {
-  GL_SERVICE_LOG("glTexParameterfv"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexParameterfvFn != nullptr);
-  g_driver_gl.debug_fn.glTexParameterfvFn(target, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glTexParameterfvRobustANGLE(GLenum target,
-                                  GLenum pname,
-                                  GLsizei bufSize,
-                                  const GLfloat* params) {
-  GL_SERVICE_LOG("glTexParameterfvRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexParameterfvRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glTexParameterfvRobustANGLEFn(target, pname, bufSize,
-                                                     params);
-}
-
-static void GL_BINDING_CALL Debug_glTexParameteri(GLenum target,
-                                                  GLenum pname,
-                                                  GLint param) {
-  GL_SERVICE_LOG("glTexParameteri"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << param << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexParameteriFn != nullptr);
-  g_driver_gl.debug_fn.glTexParameteriFn(target, pname, param);
-}
-
-static void GL_BINDING_CALL
-Debug_glTexParameterIivRobustANGLE(GLenum target,
-                                   GLenum pname,
-                                   GLsizei bufSize,
-                                   const GLint* params) {
-  GL_SERVICE_LOG("glTexParameterIivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexParameterIivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glTexParameterIivRobustANGLEFn(target, pname, bufSize,
-                                                      params);
-}
-
-static void GL_BINDING_CALL
-Debug_glTexParameterIuivRobustANGLE(GLenum target,
-                                    GLenum pname,
-                                    GLsizei bufSize,
-                                    const GLuint* params) {
-  GL_SERVICE_LOG("glTexParameterIuivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexParameterIuivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glTexParameterIuivRobustANGLEFn(target, pname, bufSize,
-                                                       params);
-}
-
-static void GL_BINDING_CALL Debug_glTexParameteriv(GLenum target,
-                                                   GLenum pname,
-                                                   const GLint* params) {
-  GL_SERVICE_LOG("glTexParameteriv"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexParameterivFn != nullptr);
-  g_driver_gl.debug_fn.glTexParameterivFn(target, pname, params);
-}
-
-static void GL_BINDING_CALL
-Debug_glTexParameterivRobustANGLE(GLenum target,
-                                  GLenum pname,
-                                  GLsizei bufSize,
-                                  const GLint* params) {
-  GL_SERVICE_LOG("glTexParameterivRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", "
-                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
-                 << static_cast<const void*>(params) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexParameterivRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glTexParameterivRobustANGLEFn(target, pname, bufSize,
-                                                     params);
-}
-
-static void GL_BINDING_CALL Debug_glTexStorage2DEXT(GLenum target,
-                                                    GLsizei levels,
-                                                    GLenum internalformat,
-                                                    GLsizei width,
-                                                    GLsizei height) {
-  GL_SERVICE_LOG("glTexStorage2DEXT"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << levels
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
-                 << width << ", " << height << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexStorage2DEXTFn != nullptr);
-  g_driver_gl.debug_fn.glTexStorage2DEXTFn(target, levels, internalformat,
-                                           width, height);
-}
-
-static void GL_BINDING_CALL Debug_glTexStorage3D(GLenum target,
-                                                 GLsizei levels,
-                                                 GLenum internalformat,
-                                                 GLsizei width,
-                                                 GLsizei height,
-                                                 GLsizei depth) {
-  GL_SERVICE_LOG("glTexStorage3D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << levels
-                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
-                 << width << ", " << height << ", " << depth << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexStorage3DFn != nullptr);
-  g_driver_gl.debug_fn.glTexStorage3DFn(target, levels, internalformat, width,
-                                        height, depth);
-}
-
-static void GL_BINDING_CALL Debug_glTexSubImage2D(GLenum target,
-                                                  GLint level,
-                                                  GLint xoffset,
-                                                  GLint yoffset,
-                                                  GLsizei width,
-                                                  GLsizei height,
-                                                  GLenum format,
-                                                  GLenum type,
-                                                  const void* pixels) {
-  GL_SERVICE_LOG("glTexSubImage2D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << xoffset << ", " << yoffset << ", " << width << ", "
-                 << height << ", " << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexSubImage2DFn != nullptr);
-  g_driver_gl.debug_fn.glTexSubImage2DFn(target, level, xoffset, yoffset, width,
-                                         height, format, type, pixels);
-}
-
-static void GL_BINDING_CALL
-Debug_glTexSubImage2DRobustANGLE(GLenum target,
-                                 GLint level,
-                                 GLint xoffset,
-                                 GLint yoffset,
-                                 GLsizei width,
-                                 GLsizei height,
-                                 GLenum format,
-                                 GLenum type,
-                                 GLsizei bufSize,
-                                 const void* pixels) {
-  GL_SERVICE_LOG("glTexSubImage2DRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << xoffset << ", " << yoffset << ", " << width << ", "
-                 << height << ", " << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexSubImage2DRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glTexSubImage2DRobustANGLEFn(
-      target, level, xoffset, yoffset, width, height, format, type, bufSize,
-      pixels);
-}
-
-static void GL_BINDING_CALL Debug_glTexSubImage3D(GLenum target,
-                                                  GLint level,
-                                                  GLint xoffset,
-                                                  GLint yoffset,
-                                                  GLint zoffset,
-                                                  GLsizei width,
-                                                  GLsizei height,
-                                                  GLsizei depth,
-                                                  GLenum format,
-                                                  GLenum type,
-                                                  const void* pixels) {
-  GL_SERVICE_LOG("glTexSubImage3D"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << xoffset << ", " << yoffset << ", " << zoffset
-                 << ", " << width << ", " << height << ", " << depth << ", "
-                 << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexSubImage3DFn != nullptr);
-  g_driver_gl.debug_fn.glTexSubImage3DFn(target, level, xoffset, yoffset,
-                                         zoffset, width, height, depth, format,
-                                         type, pixels);
-}
-
-static void GL_BINDING_CALL
-Debug_glTexSubImage3DRobustANGLE(GLenum target,
-                                 GLint level,
-                                 GLint xoffset,
-                                 GLint yoffset,
-                                 GLint zoffset,
-                                 GLsizei width,
-                                 GLsizei height,
-                                 GLsizei depth,
-                                 GLenum format,
-                                 GLenum type,
-                                 GLsizei bufSize,
-                                 const void* pixels) {
-  GL_SERVICE_LOG("glTexSubImage3DRobustANGLE"
-                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
-                 << ", " << xoffset << ", " << yoffset << ", " << zoffset
-                 << ", " << width << ", " << height << ", " << depth << ", "
-                 << GLEnums::GetStringEnum(format) << ", "
-                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
-                 << static_cast<const void*>(pixels) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTexSubImage3DRobustANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glTexSubImage3DRobustANGLEFn(
-      target, level, xoffset, yoffset, zoffset, width, height, depth, format,
-      type, bufSize, pixels);
-}
-
-static void GL_BINDING_CALL
-Debug_glTransformFeedbackVaryings(GLuint program,
-                                  GLsizei count,
-                                  const char* const* varyings,
-                                  GLenum bufferMode) {
-  GL_SERVICE_LOG("glTransformFeedbackVaryings"
-                 << "(" << program << ", " << count << ", "
-                 << static_cast<const void*>(varyings) << ", "
-                 << GLEnums::GetStringEnum(bufferMode) << ")");
-  DCHECK(g_driver_gl.debug_fn.glTransformFeedbackVaryingsFn != nullptr);
-  g_driver_gl.debug_fn.glTransformFeedbackVaryingsFn(program, count, varyings,
-                                                     bufferMode);
-}
-
-static void GL_BINDING_CALL Debug_glUniform1f(GLint location, GLfloat x) {
-  GL_SERVICE_LOG("glUniform1f"
-                 << "(" << location << ", " << x << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform1fFn != nullptr);
-  g_driver_gl.debug_fn.glUniform1fFn(location, x);
-}
-
-static void GL_BINDING_CALL Debug_glUniform1fv(GLint location,
-                                               GLsizei count,
-                                               const GLfloat* v) {
-  GL_SERVICE_LOG("glUniform1fv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform1fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniform1fvFn(location, count, v);
-}
-
-static void GL_BINDING_CALL Debug_glUniform1i(GLint location, GLint x) {
-  GL_SERVICE_LOG("glUniform1i"
-                 << "(" << location << ", " << x << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform1iFn != nullptr);
-  g_driver_gl.debug_fn.glUniform1iFn(location, x);
-}
-
-static void GL_BINDING_CALL Debug_glUniform1iv(GLint location,
-                                               GLsizei count,
-                                               const GLint* v) {
-  GL_SERVICE_LOG("glUniform1iv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform1ivFn != nullptr);
-  g_driver_gl.debug_fn.glUniform1ivFn(location, count, v);
-}
-
-static void GL_BINDING_CALL Debug_glUniform1ui(GLint location, GLuint v0) {
-  GL_SERVICE_LOG("glUniform1ui"
-                 << "(" << location << ", " << v0 << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform1uiFn != nullptr);
-  g_driver_gl.debug_fn.glUniform1uiFn(location, v0);
-}
-
-static void GL_BINDING_CALL Debug_glUniform1uiv(GLint location,
-                                                GLsizei count,
-                                                const GLuint* v) {
-  GL_SERVICE_LOG("glUniform1uiv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform1uivFn != nullptr);
-  g_driver_gl.debug_fn.glUniform1uivFn(location, count, v);
-}
-
-static void GL_BINDING_CALL Debug_glUniform2f(GLint location,
-                                              GLfloat x,
-                                              GLfloat y) {
-  GL_SERVICE_LOG("glUniform2f"
-                 << "(" << location << ", " << x << ", " << y << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform2fFn != nullptr);
-  g_driver_gl.debug_fn.glUniform2fFn(location, x, y);
-}
-
-static void GL_BINDING_CALL Debug_glUniform2fv(GLint location,
-                                               GLsizei count,
-                                               const GLfloat* v) {
-  GL_SERVICE_LOG("glUniform2fv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform2fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniform2fvFn(location, count, v);
-}
-
-static void GL_BINDING_CALL Debug_glUniform2i(GLint location,
-                                              GLint x,
-                                              GLint y) {
-  GL_SERVICE_LOG("glUniform2i"
-                 << "(" << location << ", " << x << ", " << y << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform2iFn != nullptr);
-  g_driver_gl.debug_fn.glUniform2iFn(location, x, y);
-}
-
-static void GL_BINDING_CALL Debug_glUniform2iv(GLint location,
-                                               GLsizei count,
-                                               const GLint* v) {
-  GL_SERVICE_LOG("glUniform2iv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform2ivFn != nullptr);
-  g_driver_gl.debug_fn.glUniform2ivFn(location, count, v);
-}
-
-static void GL_BINDING_CALL Debug_glUniform2ui(GLint location,
-                                               GLuint v0,
-                                               GLuint v1) {
-  GL_SERVICE_LOG("glUniform2ui"
-                 << "(" << location << ", " << v0 << ", " << v1 << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform2uiFn != nullptr);
-  g_driver_gl.debug_fn.glUniform2uiFn(location, v0, v1);
-}
-
-static void GL_BINDING_CALL Debug_glUniform2uiv(GLint location,
-                                                GLsizei count,
-                                                const GLuint* v) {
-  GL_SERVICE_LOG("glUniform2uiv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform2uivFn != nullptr);
-  g_driver_gl.debug_fn.glUniform2uivFn(location, count, v);
-}
-
-static void GL_BINDING_CALL Debug_glUniform3f(GLint location,
-                                              GLfloat x,
-                                              GLfloat y,
-                                              GLfloat z) {
-  GL_SERVICE_LOG("glUniform3f"
-                 << "(" << location << ", " << x << ", " << y << ", " << z
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform3fFn != nullptr);
-  g_driver_gl.debug_fn.glUniform3fFn(location, x, y, z);
-}
-
-static void GL_BINDING_CALL Debug_glUniform3fv(GLint location,
-                                               GLsizei count,
-                                               const GLfloat* v) {
-  GL_SERVICE_LOG("glUniform3fv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform3fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniform3fvFn(location, count, v);
-}
-
-static void GL_BINDING_CALL Debug_glUniform3i(GLint location,
-                                              GLint x,
-                                              GLint y,
-                                              GLint z) {
-  GL_SERVICE_LOG("glUniform3i"
-                 << "(" << location << ", " << x << ", " << y << ", " << z
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform3iFn != nullptr);
-  g_driver_gl.debug_fn.glUniform3iFn(location, x, y, z);
-}
-
-static void GL_BINDING_CALL Debug_glUniform3iv(GLint location,
-                                               GLsizei count,
-                                               const GLint* v) {
-  GL_SERVICE_LOG("glUniform3iv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform3ivFn != nullptr);
-  g_driver_gl.debug_fn.glUniform3ivFn(location, count, v);
-}
-
-static void GL_BINDING_CALL Debug_glUniform3ui(GLint location,
-                                               GLuint v0,
-                                               GLuint v1,
-                                               GLuint v2) {
-  GL_SERVICE_LOG("glUniform3ui"
-                 << "(" << location << ", " << v0 << ", " << v1 << ", " << v2
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform3uiFn != nullptr);
-  g_driver_gl.debug_fn.glUniform3uiFn(location, v0, v1, v2);
-}
-
-static void GL_BINDING_CALL Debug_glUniform3uiv(GLint location,
-                                                GLsizei count,
-                                                const GLuint* v) {
-  GL_SERVICE_LOG("glUniform3uiv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform3uivFn != nullptr);
-  g_driver_gl.debug_fn.glUniform3uivFn(location, count, v);
-}
-
-static void GL_BINDING_CALL
-Debug_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
-  GL_SERVICE_LOG("glUniform4f"
-                 << "(" << location << ", " << x << ", " << y << ", " << z
-                 << ", " << w << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform4fFn != nullptr);
-  g_driver_gl.debug_fn.glUniform4fFn(location, x, y, z, w);
-}
-
-static void GL_BINDING_CALL Debug_glUniform4fv(GLint location,
-                                               GLsizei count,
-                                               const GLfloat* v) {
-  GL_SERVICE_LOG("glUniform4fv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform4fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniform4fvFn(location, count, v);
-}
-
-static void GL_BINDING_CALL
-Debug_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
-  GL_SERVICE_LOG("glUniform4i"
-                 << "(" << location << ", " << x << ", " << y << ", " << z
-                 << ", " << w << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform4iFn != nullptr);
-  g_driver_gl.debug_fn.glUniform4iFn(location, x, y, z, w);
-}
-
-static void GL_BINDING_CALL Debug_glUniform4iv(GLint location,
-                                               GLsizei count,
-                                               const GLint* v) {
-  GL_SERVICE_LOG("glUniform4iv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform4ivFn != nullptr);
-  g_driver_gl.debug_fn.glUniform4ivFn(location, count, v);
-}
-
-static void GL_BINDING_CALL
-Debug_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
-  GL_SERVICE_LOG("glUniform4ui"
-                 << "(" << location << ", " << v0 << ", " << v1 << ", " << v2
-                 << ", " << v3 << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform4uiFn != nullptr);
-  g_driver_gl.debug_fn.glUniform4uiFn(location, v0, v1, v2, v3);
-}
-
-static void GL_BINDING_CALL Debug_glUniform4uiv(GLint location,
-                                                GLsizei count,
-                                                const GLuint* v) {
-  GL_SERVICE_LOG("glUniform4uiv"
-                 << "(" << location << ", " << count << ", "
-                 << static_cast<const void*>(v) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniform4uivFn != nullptr);
-  g_driver_gl.debug_fn.glUniform4uivFn(location, count, v);
-}
-
-static void GL_BINDING_CALL
-Debug_glUniformBlockBinding(GLuint program,
-                            GLuint uniformBlockIndex,
-                            GLuint uniformBlockBinding) {
-  GL_SERVICE_LOG("glUniformBlockBinding"
-                 << "(" << program << ", " << uniformBlockIndex << ", "
-                 << uniformBlockBinding << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformBlockBindingFn != nullptr);
-  g_driver_gl.debug_fn.glUniformBlockBindingFn(program, uniformBlockIndex,
-                                               uniformBlockBinding);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix2fv(GLint location,
-                                                     GLsizei count,
-                                                     GLboolean transpose,
-                                                     const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix2fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix2fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix2fvFn(location, count, transpose, value);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix2x3fv(GLint location,
-                                                       GLsizei count,
-                                                       GLboolean transpose,
-                                                       const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix2x3fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix2x3fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix2x3fvFn(location, count, transpose,
-                                              value);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix2x4fv(GLint location,
-                                                       GLsizei count,
-                                                       GLboolean transpose,
-                                                       const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix2x4fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix2x4fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix2x4fvFn(location, count, transpose,
-                                              value);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix3fv(GLint location,
-                                                     GLsizei count,
-                                                     GLboolean transpose,
-                                                     const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix3fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix3fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix3fvFn(location, count, transpose, value);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix3x2fv(GLint location,
-                                                       GLsizei count,
-                                                       GLboolean transpose,
-                                                       const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix3x2fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix3x2fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix3x2fvFn(location, count, transpose,
-                                              value);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix3x4fv(GLint location,
-                                                       GLsizei count,
-                                                       GLboolean transpose,
-                                                       const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix3x4fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix3x4fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix3x4fvFn(location, count, transpose,
-                                              value);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix4fv(GLint location,
-                                                     GLsizei count,
-                                                     GLboolean transpose,
-                                                     const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix4fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix4fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix4fvFn(location, count, transpose, value);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix4x2fv(GLint location,
-                                                       GLsizei count,
-                                                       GLboolean transpose,
-                                                       const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix4x2fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix4x2fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix4x2fvFn(location, count, transpose,
-                                              value);
-}
-
-static void GL_BINDING_CALL Debug_glUniformMatrix4x3fv(GLint location,
-                                                       GLsizei count,
-                                                       GLboolean transpose,
-                                                       const GLfloat* value) {
-  GL_SERVICE_LOG("glUniformMatrix4x3fv"
-                 << "(" << location << ", " << count << ", "
-                 << GLEnums::GetStringBool(transpose) << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUniformMatrix4x3fvFn != nullptr);
-  g_driver_gl.debug_fn.glUniformMatrix4x3fvFn(location, count, transpose,
-                                              value);
-}
-
-static GLboolean GL_BINDING_CALL Debug_glUnmapBuffer(GLenum target) {
-  GL_SERVICE_LOG("glUnmapBuffer"
-                 << "(" << GLEnums::GetStringEnum(target) << ")");
-  DCHECK(g_driver_gl.debug_fn.glUnmapBufferFn != nullptr);
-  GLboolean result = g_driver_gl.debug_fn.glUnmapBufferFn(target);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glUseProgram(GLuint program) {
-  GL_SERVICE_LOG("glUseProgram"
-                 << "(" << program << ")");
-  DCHECK(g_driver_gl.debug_fn.glUseProgramFn != nullptr);
-  g_driver_gl.debug_fn.glUseProgramFn(program);
-}
-
-static void GL_BINDING_CALL Debug_glValidateProgram(GLuint program) {
-  GL_SERVICE_LOG("glValidateProgram"
-                 << "(" << program << ")");
-  DCHECK(g_driver_gl.debug_fn.glValidateProgramFn != nullptr);
-  g_driver_gl.debug_fn.glValidateProgramFn(program);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttrib1f(GLuint indx, GLfloat x) {
-  GL_SERVICE_LOG("glVertexAttrib1f"
-                 << "(" << indx << ", " << x << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttrib1fFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttrib1fFn(indx, x);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttrib1fv(GLuint indx,
-                                                    const GLfloat* values) {
-  GL_SERVICE_LOG("glVertexAttrib1fv"
-                 << "(" << indx << ", " << static_cast<const void*>(values)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttrib1fvFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttrib1fvFn(indx, values);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttrib2f(GLuint indx,
-                                                   GLfloat x,
-                                                   GLfloat y) {
-  GL_SERVICE_LOG("glVertexAttrib2f"
-                 << "(" << indx << ", " << x << ", " << y << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttrib2fFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttrib2fFn(indx, x, y);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttrib2fv(GLuint indx,
-                                                    const GLfloat* values) {
-  GL_SERVICE_LOG("glVertexAttrib2fv"
-                 << "(" << indx << ", " << static_cast<const void*>(values)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttrib2fvFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttrib2fvFn(indx, values);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttrib3f(GLuint indx,
-                                                   GLfloat x,
-                                                   GLfloat y,
-                                                   GLfloat z) {
-  GL_SERVICE_LOG("glVertexAttrib3f"
-                 << "(" << indx << ", " << x << ", " << y << ", " << z << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttrib3fFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttrib3fFn(indx, x, y, z);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttrib3fv(GLuint indx,
-                                                    const GLfloat* values) {
-  GL_SERVICE_LOG("glVertexAttrib3fv"
-                 << "(" << indx << ", " << static_cast<const void*>(values)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttrib3fvFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttrib3fvFn(indx, values);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttrib4f(GLuint indx,
-                                                   GLfloat x,
-                                                   GLfloat y,
-                                                   GLfloat z,
-                                                   GLfloat w) {
-  GL_SERVICE_LOG("glVertexAttrib4f"
-                 << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
-                 << w << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttrib4fFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttrib4fFn(indx, x, y, z, w);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttrib4fv(GLuint indx,
-                                                    const GLfloat* values) {
-  GL_SERVICE_LOG("glVertexAttrib4fv"
-                 << "(" << indx << ", " << static_cast<const void*>(values)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttrib4fvFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttrib4fvFn(indx, values);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttribDivisorANGLE(GLuint index,
-                                                             GLuint divisor) {
-  GL_SERVICE_LOG("glVertexAttribDivisorANGLE"
-                 << "(" << index << ", " << divisor << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttribDivisorANGLEFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttribDivisorANGLEFn(index, divisor);
-}
-
-static void GL_BINDING_CALL
-Debug_glVertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) {
-  GL_SERVICE_LOG("glVertexAttribI4i"
-                 << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
-                 << w << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttribI4iFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttribI4iFn(indx, x, y, z, w);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttribI4iv(GLuint indx,
-                                                     const GLint* values) {
-  GL_SERVICE_LOG("glVertexAttribI4iv"
-                 << "(" << indx << ", " << static_cast<const void*>(values)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttribI4ivFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttribI4ivFn(indx, values);
-}
-
-static void GL_BINDING_CALL
-Debug_glVertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w) {
-  GL_SERVICE_LOG("glVertexAttribI4ui"
-                 << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
-                 << w << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttribI4uiFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttribI4uiFn(indx, x, y, z, w);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttribI4uiv(GLuint indx,
-                                                      const GLuint* values) {
-  GL_SERVICE_LOG("glVertexAttribI4uiv"
-                 << "(" << indx << ", " << static_cast<const void*>(values)
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttribI4uivFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttribI4uivFn(indx, values);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttribIPointer(GLuint indx,
-                                                         GLint size,
-                                                         GLenum type,
-                                                         GLsizei stride,
-                                                         const void* ptr) {
-  GL_SERVICE_LOG("glVertexAttribIPointer"
-                 << "(" << indx << ", " << size << ", "
-                 << GLEnums::GetStringEnum(type) << ", " << stride << ", "
-                 << static_cast<const void*>(ptr) << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttribIPointerFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttribIPointerFn(indx, size, type, stride, ptr);
-}
-
-static void GL_BINDING_CALL Debug_glVertexAttribPointer(GLuint indx,
-                                                        GLint size,
-                                                        GLenum type,
-                                                        GLboolean normalized,
-                                                        GLsizei stride,
-                                                        const void* ptr) {
-  GL_SERVICE_LOG("glVertexAttribPointer"
-                 << "(" << indx << ", " << size << ", "
-                 << GLEnums::GetStringEnum(type) << ", "
-                 << GLEnums::GetStringBool(normalized) << ", " << stride << ", "
-                 << static_cast<const void*>(ptr) << ")");
-  DCHECK(g_driver_gl.debug_fn.glVertexAttribPointerFn != nullptr);
-  g_driver_gl.debug_fn.glVertexAttribPointerFn(indx, size, type, normalized,
-                                               stride, ptr);
-}
-
-static void GL_BINDING_CALL Debug_glViewport(GLint x,
-                                             GLint y,
-                                             GLsizei width,
-                                             GLsizei height) {
-  GL_SERVICE_LOG("glViewport"
-                 << "(" << x << ", " << y << ", " << width << ", " << height
-                 << ")");
-  DCHECK(g_driver_gl.debug_fn.glViewportFn != nullptr);
-  g_driver_gl.debug_fn.glViewportFn(x, y, width, height);
-}
-
-static GLenum GL_BINDING_CALL Debug_glWaitSync(GLsync sync,
-                                               GLbitfield flags,
-                                               GLuint64 timeout) {
-  GL_SERVICE_LOG("glWaitSync"
-                 << "(" << sync << ", " << flags << ", " << timeout << ")");
-  DCHECK(g_driver_gl.debug_fn.glWaitSyncFn != nullptr);
-  GLenum result = g_driver_gl.debug_fn.glWaitSyncFn(sync, flags, timeout);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-}  // extern "C"
-
-void DriverGL::InitializeDebugBindings() {
-  if (!debug_fn.glActiveTextureFn) {
-    debug_fn.glActiveTextureFn = fn.glActiveTextureFn;
-    fn.glActiveTextureFn = Debug_glActiveTexture;
-  }
-  if (!debug_fn.glApplyFramebufferAttachmentCMAAINTELFn) {
-    debug_fn.glApplyFramebufferAttachmentCMAAINTELFn =
-        fn.glApplyFramebufferAttachmentCMAAINTELFn;
-    fn.glApplyFramebufferAttachmentCMAAINTELFn =
-        Debug_glApplyFramebufferAttachmentCMAAINTEL;
-  }
-  if (!debug_fn.glAttachShaderFn) {
-    debug_fn.glAttachShaderFn = fn.glAttachShaderFn;
-    fn.glAttachShaderFn = Debug_glAttachShader;
-  }
-  if (!debug_fn.glBeginQueryFn) {
-    debug_fn.glBeginQueryFn = fn.glBeginQueryFn;
-    fn.glBeginQueryFn = Debug_glBeginQuery;
-  }
-  if (!debug_fn.glBeginTransformFeedbackFn) {
-    debug_fn.glBeginTransformFeedbackFn = fn.glBeginTransformFeedbackFn;
-    fn.glBeginTransformFeedbackFn = Debug_glBeginTransformFeedback;
-  }
-  if (!debug_fn.glBindAttribLocationFn) {
-    debug_fn.glBindAttribLocationFn = fn.glBindAttribLocationFn;
-    fn.glBindAttribLocationFn = Debug_glBindAttribLocation;
-  }
-  if (!debug_fn.glBindBufferFn) {
-    debug_fn.glBindBufferFn = fn.glBindBufferFn;
-    fn.glBindBufferFn = Debug_glBindBuffer;
-  }
-  if (!debug_fn.glBindBufferBaseFn) {
-    debug_fn.glBindBufferBaseFn = fn.glBindBufferBaseFn;
-    fn.glBindBufferBaseFn = Debug_glBindBufferBase;
-  }
-  if (!debug_fn.glBindBufferRangeFn) {
-    debug_fn.glBindBufferRangeFn = fn.glBindBufferRangeFn;
-    fn.glBindBufferRangeFn = Debug_glBindBufferRange;
-  }
-  if (!debug_fn.glBindFragDataLocationFn) {
-    debug_fn.glBindFragDataLocationFn = fn.glBindFragDataLocationFn;
-    fn.glBindFragDataLocationFn = Debug_glBindFragDataLocation;
-  }
-  if (!debug_fn.glBindFragDataLocationIndexedFn) {
-    debug_fn.glBindFragDataLocationIndexedFn =
-        fn.glBindFragDataLocationIndexedFn;
-    fn.glBindFragDataLocationIndexedFn = Debug_glBindFragDataLocationIndexed;
-  }
-  if (!debug_fn.glBindFramebufferEXTFn) {
-    debug_fn.glBindFramebufferEXTFn = fn.glBindFramebufferEXTFn;
-    fn.glBindFramebufferEXTFn = Debug_glBindFramebufferEXT;
-  }
-  if (!debug_fn.glBindImageTextureEXTFn) {
-    debug_fn.glBindImageTextureEXTFn = fn.glBindImageTextureEXTFn;
-    fn.glBindImageTextureEXTFn = Debug_glBindImageTextureEXT;
-  }
-  if (!debug_fn.glBindRenderbufferEXTFn) {
-    debug_fn.glBindRenderbufferEXTFn = fn.glBindRenderbufferEXTFn;
-    fn.glBindRenderbufferEXTFn = Debug_glBindRenderbufferEXT;
-  }
-  if (!debug_fn.glBindSamplerFn) {
-    debug_fn.glBindSamplerFn = fn.glBindSamplerFn;
-    fn.glBindSamplerFn = Debug_glBindSampler;
-  }
-  if (!debug_fn.glBindTextureFn) {
-    debug_fn.glBindTextureFn = fn.glBindTextureFn;
-    fn.glBindTextureFn = Debug_glBindTexture;
-  }
-  if (!debug_fn.glBindTransformFeedbackFn) {
-    debug_fn.glBindTransformFeedbackFn = fn.glBindTransformFeedbackFn;
-    fn.glBindTransformFeedbackFn = Debug_glBindTransformFeedback;
-  }
-  if (!debug_fn.glBindUniformLocationCHROMIUMFn) {
-    debug_fn.glBindUniformLocationCHROMIUMFn =
-        fn.glBindUniformLocationCHROMIUMFn;
-    fn.glBindUniformLocationCHROMIUMFn = Debug_glBindUniformLocationCHROMIUM;
-  }
-  if (!debug_fn.glBindVertexArrayOESFn) {
-    debug_fn.glBindVertexArrayOESFn = fn.glBindVertexArrayOESFn;
-    fn.glBindVertexArrayOESFn = Debug_glBindVertexArrayOES;
-  }
-  if (!debug_fn.glBlendBarrierKHRFn) {
-    debug_fn.glBlendBarrierKHRFn = fn.glBlendBarrierKHRFn;
-    fn.glBlendBarrierKHRFn = Debug_glBlendBarrierKHR;
-  }
-  if (!debug_fn.glBlendColorFn) {
-    debug_fn.glBlendColorFn = fn.glBlendColorFn;
-    fn.glBlendColorFn = Debug_glBlendColor;
-  }
-  if (!debug_fn.glBlendEquationFn) {
-    debug_fn.glBlendEquationFn = fn.glBlendEquationFn;
-    fn.glBlendEquationFn = Debug_glBlendEquation;
-  }
-  if (!debug_fn.glBlendEquationSeparateFn) {
-    debug_fn.glBlendEquationSeparateFn = fn.glBlendEquationSeparateFn;
-    fn.glBlendEquationSeparateFn = Debug_glBlendEquationSeparate;
-  }
-  if (!debug_fn.glBlendFuncFn) {
-    debug_fn.glBlendFuncFn = fn.glBlendFuncFn;
-    fn.glBlendFuncFn = Debug_glBlendFunc;
-  }
-  if (!debug_fn.glBlendFuncSeparateFn) {
-    debug_fn.glBlendFuncSeparateFn = fn.glBlendFuncSeparateFn;
-    fn.glBlendFuncSeparateFn = Debug_glBlendFuncSeparate;
-  }
-  if (!debug_fn.glBlitFramebufferFn) {
-    debug_fn.glBlitFramebufferFn = fn.glBlitFramebufferFn;
-    fn.glBlitFramebufferFn = Debug_glBlitFramebuffer;
-  }
-  if (!debug_fn.glBlitFramebufferANGLEFn) {
-    debug_fn.glBlitFramebufferANGLEFn = fn.glBlitFramebufferANGLEFn;
-    fn.glBlitFramebufferANGLEFn = Debug_glBlitFramebufferANGLE;
-  }
-  if (!debug_fn.glBlitFramebufferEXTFn) {
-    debug_fn.glBlitFramebufferEXTFn = fn.glBlitFramebufferEXTFn;
-    fn.glBlitFramebufferEXTFn = Debug_glBlitFramebufferEXT;
-  }
-  if (!debug_fn.glBufferDataFn) {
-    debug_fn.glBufferDataFn = fn.glBufferDataFn;
-    fn.glBufferDataFn = Debug_glBufferData;
-  }
-  if (!debug_fn.glBufferSubDataFn) {
-    debug_fn.glBufferSubDataFn = fn.glBufferSubDataFn;
-    fn.glBufferSubDataFn = Debug_glBufferSubData;
-  }
-  if (!debug_fn.glCheckFramebufferStatusEXTFn) {
-    debug_fn.glCheckFramebufferStatusEXTFn = fn.glCheckFramebufferStatusEXTFn;
-    fn.glCheckFramebufferStatusEXTFn = Debug_glCheckFramebufferStatusEXT;
-  }
-  if (!debug_fn.glClearFn) {
-    debug_fn.glClearFn = fn.glClearFn;
-    fn.glClearFn = Debug_glClear;
-  }
-  if (!debug_fn.glClearBufferfiFn) {
-    debug_fn.glClearBufferfiFn = fn.glClearBufferfiFn;
-    fn.glClearBufferfiFn = Debug_glClearBufferfi;
-  }
-  if (!debug_fn.glClearBufferfvFn) {
-    debug_fn.glClearBufferfvFn = fn.glClearBufferfvFn;
-    fn.glClearBufferfvFn = Debug_glClearBufferfv;
-  }
-  if (!debug_fn.glClearBufferivFn) {
-    debug_fn.glClearBufferivFn = fn.glClearBufferivFn;
-    fn.glClearBufferivFn = Debug_glClearBufferiv;
-  }
-  if (!debug_fn.glClearBufferuivFn) {
-    debug_fn.glClearBufferuivFn = fn.glClearBufferuivFn;
-    fn.glClearBufferuivFn = Debug_glClearBufferuiv;
-  }
-  if (!debug_fn.glClearColorFn) {
-    debug_fn.glClearColorFn = fn.glClearColorFn;
-    fn.glClearColorFn = Debug_glClearColor;
-  }
-  if (!debug_fn.glClearDepthFn) {
-    debug_fn.glClearDepthFn = fn.glClearDepthFn;
-    fn.glClearDepthFn = Debug_glClearDepth;
-  }
-  if (!debug_fn.glClearDepthfFn) {
-    debug_fn.glClearDepthfFn = fn.glClearDepthfFn;
-    fn.glClearDepthfFn = Debug_glClearDepthf;
-  }
-  if (!debug_fn.glClearStencilFn) {
-    debug_fn.glClearStencilFn = fn.glClearStencilFn;
-    fn.glClearStencilFn = Debug_glClearStencil;
-  }
-  if (!debug_fn.glClientWaitSyncFn) {
-    debug_fn.glClientWaitSyncFn = fn.glClientWaitSyncFn;
-    fn.glClientWaitSyncFn = Debug_glClientWaitSync;
-  }
-  if (!debug_fn.glColorMaskFn) {
-    debug_fn.glColorMaskFn = fn.glColorMaskFn;
-    fn.glColorMaskFn = Debug_glColorMask;
-  }
-  if (!debug_fn.glCompileShaderFn) {
-    debug_fn.glCompileShaderFn = fn.glCompileShaderFn;
-    fn.glCompileShaderFn = Debug_glCompileShader;
-  }
-  if (!debug_fn.glCompressedCopyTextureCHROMIUMFn) {
-    debug_fn.glCompressedCopyTextureCHROMIUMFn =
-        fn.glCompressedCopyTextureCHROMIUMFn;
-    fn.glCompressedCopyTextureCHROMIUMFn =
-        Debug_glCompressedCopyTextureCHROMIUM;
-  }
-  if (!debug_fn.glCompressedTexImage2DFn) {
-    debug_fn.glCompressedTexImage2DFn = fn.glCompressedTexImage2DFn;
-    fn.glCompressedTexImage2DFn = Debug_glCompressedTexImage2D;
-  }
-  if (!debug_fn.glCompressedTexImage3DFn) {
-    debug_fn.glCompressedTexImage3DFn = fn.glCompressedTexImage3DFn;
-    fn.glCompressedTexImage3DFn = Debug_glCompressedTexImage3D;
-  }
-  if (!debug_fn.glCompressedTexSubImage2DFn) {
-    debug_fn.glCompressedTexSubImage2DFn = fn.glCompressedTexSubImage2DFn;
-    fn.glCompressedTexSubImage2DFn = Debug_glCompressedTexSubImage2D;
-  }
-  if (!debug_fn.glCompressedTexSubImage3DFn) {
-    debug_fn.glCompressedTexSubImage3DFn = fn.glCompressedTexSubImage3DFn;
-    fn.glCompressedTexSubImage3DFn = Debug_glCompressedTexSubImage3D;
-  }
-  if (!debug_fn.glCopyBufferSubDataFn) {
-    debug_fn.glCopyBufferSubDataFn = fn.glCopyBufferSubDataFn;
-    fn.glCopyBufferSubDataFn = Debug_glCopyBufferSubData;
-  }
-  if (!debug_fn.glCopySubTextureCHROMIUMFn) {
-    debug_fn.glCopySubTextureCHROMIUMFn = fn.glCopySubTextureCHROMIUMFn;
-    fn.glCopySubTextureCHROMIUMFn = Debug_glCopySubTextureCHROMIUM;
-  }
-  if (!debug_fn.glCopyTexImage2DFn) {
-    debug_fn.glCopyTexImage2DFn = fn.glCopyTexImage2DFn;
-    fn.glCopyTexImage2DFn = Debug_glCopyTexImage2D;
-  }
-  if (!debug_fn.glCopyTexSubImage2DFn) {
-    debug_fn.glCopyTexSubImage2DFn = fn.glCopyTexSubImage2DFn;
-    fn.glCopyTexSubImage2DFn = Debug_glCopyTexSubImage2D;
-  }
-  if (!debug_fn.glCopyTexSubImage3DFn) {
-    debug_fn.glCopyTexSubImage3DFn = fn.glCopyTexSubImage3DFn;
-    fn.glCopyTexSubImage3DFn = Debug_glCopyTexSubImage3D;
-  }
-  if (!debug_fn.glCopyTextureCHROMIUMFn) {
-    debug_fn.glCopyTextureCHROMIUMFn = fn.glCopyTextureCHROMIUMFn;
-    fn.glCopyTextureCHROMIUMFn = Debug_glCopyTextureCHROMIUM;
-  }
-  if (!debug_fn.glCoverageModulationNVFn) {
-    debug_fn.glCoverageModulationNVFn = fn.glCoverageModulationNVFn;
-    fn.glCoverageModulationNVFn = Debug_glCoverageModulationNV;
-  }
-  if (!debug_fn.glCoverFillPathInstancedNVFn) {
-    debug_fn.glCoverFillPathInstancedNVFn = fn.glCoverFillPathInstancedNVFn;
-    fn.glCoverFillPathInstancedNVFn = Debug_glCoverFillPathInstancedNV;
-  }
-  if (!debug_fn.glCoverFillPathNVFn) {
-    debug_fn.glCoverFillPathNVFn = fn.glCoverFillPathNVFn;
-    fn.glCoverFillPathNVFn = Debug_glCoverFillPathNV;
-  }
-  if (!debug_fn.glCoverStrokePathInstancedNVFn) {
-    debug_fn.glCoverStrokePathInstancedNVFn = fn.glCoverStrokePathInstancedNVFn;
-    fn.glCoverStrokePathInstancedNVFn = Debug_glCoverStrokePathInstancedNV;
-  }
-  if (!debug_fn.glCoverStrokePathNVFn) {
-    debug_fn.glCoverStrokePathNVFn = fn.glCoverStrokePathNVFn;
-    fn.glCoverStrokePathNVFn = Debug_glCoverStrokePathNV;
-  }
-  if (!debug_fn.glCreateProgramFn) {
-    debug_fn.glCreateProgramFn = fn.glCreateProgramFn;
-    fn.glCreateProgramFn = Debug_glCreateProgram;
-  }
-  if (!debug_fn.glCreateShaderFn) {
-    debug_fn.glCreateShaderFn = fn.glCreateShaderFn;
-    fn.glCreateShaderFn = Debug_glCreateShader;
-  }
-  if (!debug_fn.glCullFaceFn) {
-    debug_fn.glCullFaceFn = fn.glCullFaceFn;
-    fn.glCullFaceFn = Debug_glCullFace;
-  }
-  if (!debug_fn.glDebugMessageCallbackFn) {
-    debug_fn.glDebugMessageCallbackFn = fn.glDebugMessageCallbackFn;
-    fn.glDebugMessageCallbackFn = Debug_glDebugMessageCallback;
-  }
-  if (!debug_fn.glDebugMessageControlFn) {
-    debug_fn.glDebugMessageControlFn = fn.glDebugMessageControlFn;
-    fn.glDebugMessageControlFn = Debug_glDebugMessageControl;
-  }
-  if (!debug_fn.glDebugMessageInsertFn) {
-    debug_fn.glDebugMessageInsertFn = fn.glDebugMessageInsertFn;
-    fn.glDebugMessageInsertFn = Debug_glDebugMessageInsert;
-  }
-  if (!debug_fn.glDeleteBuffersARBFn) {
-    debug_fn.glDeleteBuffersARBFn = fn.glDeleteBuffersARBFn;
-    fn.glDeleteBuffersARBFn = Debug_glDeleteBuffersARB;
-  }
-  if (!debug_fn.glDeleteFencesAPPLEFn) {
-    debug_fn.glDeleteFencesAPPLEFn = fn.glDeleteFencesAPPLEFn;
-    fn.glDeleteFencesAPPLEFn = Debug_glDeleteFencesAPPLE;
-  }
-  if (!debug_fn.glDeleteFencesNVFn) {
-    debug_fn.glDeleteFencesNVFn = fn.glDeleteFencesNVFn;
-    fn.glDeleteFencesNVFn = Debug_glDeleteFencesNV;
-  }
-  if (!debug_fn.glDeleteFramebuffersEXTFn) {
-    debug_fn.glDeleteFramebuffersEXTFn = fn.glDeleteFramebuffersEXTFn;
-    fn.glDeleteFramebuffersEXTFn = Debug_glDeleteFramebuffersEXT;
-  }
-  if (!debug_fn.glDeletePathsNVFn) {
-    debug_fn.glDeletePathsNVFn = fn.glDeletePathsNVFn;
-    fn.glDeletePathsNVFn = Debug_glDeletePathsNV;
-  }
-  if (!debug_fn.glDeleteProgramFn) {
-    debug_fn.glDeleteProgramFn = fn.glDeleteProgramFn;
-    fn.glDeleteProgramFn = Debug_glDeleteProgram;
-  }
-  if (!debug_fn.glDeleteQueriesFn) {
-    debug_fn.glDeleteQueriesFn = fn.glDeleteQueriesFn;
-    fn.glDeleteQueriesFn = Debug_glDeleteQueries;
-  }
-  if (!debug_fn.glDeleteRenderbuffersEXTFn) {
-    debug_fn.glDeleteRenderbuffersEXTFn = fn.glDeleteRenderbuffersEXTFn;
-    fn.glDeleteRenderbuffersEXTFn = Debug_glDeleteRenderbuffersEXT;
-  }
-  if (!debug_fn.glDeleteSamplersFn) {
-    debug_fn.glDeleteSamplersFn = fn.glDeleteSamplersFn;
-    fn.glDeleteSamplersFn = Debug_glDeleteSamplers;
-  }
-  if (!debug_fn.glDeleteShaderFn) {
-    debug_fn.glDeleteShaderFn = fn.glDeleteShaderFn;
-    fn.glDeleteShaderFn = Debug_glDeleteShader;
-  }
-  if (!debug_fn.glDeleteSyncFn) {
-    debug_fn.glDeleteSyncFn = fn.glDeleteSyncFn;
-    fn.glDeleteSyncFn = Debug_glDeleteSync;
-  }
-  if (!debug_fn.glDeleteTexturesFn) {
-    debug_fn.glDeleteTexturesFn = fn.glDeleteTexturesFn;
-    fn.glDeleteTexturesFn = Debug_glDeleteTextures;
-  }
-  if (!debug_fn.glDeleteTransformFeedbacksFn) {
-    debug_fn.glDeleteTransformFeedbacksFn = fn.glDeleteTransformFeedbacksFn;
-    fn.glDeleteTransformFeedbacksFn = Debug_glDeleteTransformFeedbacks;
-  }
-  if (!debug_fn.glDeleteVertexArraysOESFn) {
-    debug_fn.glDeleteVertexArraysOESFn = fn.glDeleteVertexArraysOESFn;
-    fn.glDeleteVertexArraysOESFn = Debug_glDeleteVertexArraysOES;
-  }
-  if (!debug_fn.glDepthFuncFn) {
-    debug_fn.glDepthFuncFn = fn.glDepthFuncFn;
-    fn.glDepthFuncFn = Debug_glDepthFunc;
-  }
-  if (!debug_fn.glDepthMaskFn) {
-    debug_fn.glDepthMaskFn = fn.glDepthMaskFn;
-    fn.glDepthMaskFn = Debug_glDepthMask;
-  }
-  if (!debug_fn.glDepthRangeFn) {
-    debug_fn.glDepthRangeFn = fn.glDepthRangeFn;
-    fn.glDepthRangeFn = Debug_glDepthRange;
-  }
-  if (!debug_fn.glDepthRangefFn) {
-    debug_fn.glDepthRangefFn = fn.glDepthRangefFn;
-    fn.glDepthRangefFn = Debug_glDepthRangef;
-  }
-  if (!debug_fn.glDetachShaderFn) {
-    debug_fn.glDetachShaderFn = fn.glDetachShaderFn;
-    fn.glDetachShaderFn = Debug_glDetachShader;
-  }
-  if (!debug_fn.glDisableFn) {
-    debug_fn.glDisableFn = fn.glDisableFn;
-    fn.glDisableFn = Debug_glDisable;
-  }
-  if (!debug_fn.glDisableVertexAttribArrayFn) {
-    debug_fn.glDisableVertexAttribArrayFn = fn.glDisableVertexAttribArrayFn;
-    fn.glDisableVertexAttribArrayFn = Debug_glDisableVertexAttribArray;
-  }
-  if (!debug_fn.glDiscardFramebufferEXTFn) {
-    debug_fn.glDiscardFramebufferEXTFn = fn.glDiscardFramebufferEXTFn;
-    fn.glDiscardFramebufferEXTFn = Debug_glDiscardFramebufferEXT;
-  }
-  if (!debug_fn.glDrawArraysFn) {
-    debug_fn.glDrawArraysFn = fn.glDrawArraysFn;
-    fn.glDrawArraysFn = Debug_glDrawArrays;
-  }
-  if (!debug_fn.glDrawArraysInstancedANGLEFn) {
-    debug_fn.glDrawArraysInstancedANGLEFn = fn.glDrawArraysInstancedANGLEFn;
-    fn.glDrawArraysInstancedANGLEFn = Debug_glDrawArraysInstancedANGLE;
-  }
-  if (!debug_fn.glDrawBufferFn) {
-    debug_fn.glDrawBufferFn = fn.glDrawBufferFn;
-    fn.glDrawBufferFn = Debug_glDrawBuffer;
-  }
-  if (!debug_fn.glDrawBuffersARBFn) {
-    debug_fn.glDrawBuffersARBFn = fn.glDrawBuffersARBFn;
-    fn.glDrawBuffersARBFn = Debug_glDrawBuffersARB;
-  }
-  if (!debug_fn.glDrawElementsFn) {
-    debug_fn.glDrawElementsFn = fn.glDrawElementsFn;
-    fn.glDrawElementsFn = Debug_glDrawElements;
-  }
-  if (!debug_fn.glDrawElementsInstancedANGLEFn) {
-    debug_fn.glDrawElementsInstancedANGLEFn = fn.glDrawElementsInstancedANGLEFn;
-    fn.glDrawElementsInstancedANGLEFn = Debug_glDrawElementsInstancedANGLE;
-  }
-  if (!debug_fn.glDrawRangeElementsFn) {
-    debug_fn.glDrawRangeElementsFn = fn.glDrawRangeElementsFn;
-    fn.glDrawRangeElementsFn = Debug_glDrawRangeElements;
-  }
-  if (!debug_fn.glEGLImageTargetRenderbufferStorageOESFn) {
-    debug_fn.glEGLImageTargetRenderbufferStorageOESFn =
-        fn.glEGLImageTargetRenderbufferStorageOESFn;
-    fn.glEGLImageTargetRenderbufferStorageOESFn =
-        Debug_glEGLImageTargetRenderbufferStorageOES;
-  }
-  if (!debug_fn.glEGLImageTargetTexture2DOESFn) {
-    debug_fn.glEGLImageTargetTexture2DOESFn = fn.glEGLImageTargetTexture2DOESFn;
-    fn.glEGLImageTargetTexture2DOESFn = Debug_glEGLImageTargetTexture2DOES;
-  }
-  if (!debug_fn.glEnableFn) {
-    debug_fn.glEnableFn = fn.glEnableFn;
-    fn.glEnableFn = Debug_glEnable;
-  }
-  if (!debug_fn.glEnableVertexAttribArrayFn) {
-    debug_fn.glEnableVertexAttribArrayFn = fn.glEnableVertexAttribArrayFn;
-    fn.glEnableVertexAttribArrayFn = Debug_glEnableVertexAttribArray;
-  }
-  if (!debug_fn.glEndQueryFn) {
-    debug_fn.glEndQueryFn = fn.glEndQueryFn;
-    fn.glEndQueryFn = Debug_glEndQuery;
-  }
-  if (!debug_fn.glEndTransformFeedbackFn) {
-    debug_fn.glEndTransformFeedbackFn = fn.glEndTransformFeedbackFn;
-    fn.glEndTransformFeedbackFn = Debug_glEndTransformFeedback;
-  }
-  if (!debug_fn.glFenceSyncFn) {
-    debug_fn.glFenceSyncFn = fn.glFenceSyncFn;
-    fn.glFenceSyncFn = Debug_glFenceSync;
-  }
-  if (!debug_fn.glFinishFn) {
-    debug_fn.glFinishFn = fn.glFinishFn;
-    fn.glFinishFn = Debug_glFinish;
-  }
-  if (!debug_fn.glFinishFenceAPPLEFn) {
-    debug_fn.glFinishFenceAPPLEFn = fn.glFinishFenceAPPLEFn;
-    fn.glFinishFenceAPPLEFn = Debug_glFinishFenceAPPLE;
-  }
-  if (!debug_fn.glFinishFenceNVFn) {
-    debug_fn.glFinishFenceNVFn = fn.glFinishFenceNVFn;
-    fn.glFinishFenceNVFn = Debug_glFinishFenceNV;
-  }
-  if (!debug_fn.glFlushFn) {
-    debug_fn.glFlushFn = fn.glFlushFn;
-    fn.glFlushFn = Debug_glFlush;
-  }
-  if (!debug_fn.glFlushMappedBufferRangeFn) {
-    debug_fn.glFlushMappedBufferRangeFn = fn.glFlushMappedBufferRangeFn;
-    fn.glFlushMappedBufferRangeFn = Debug_glFlushMappedBufferRange;
-  }
-  if (!debug_fn.glFramebufferRenderbufferEXTFn) {
-    debug_fn.glFramebufferRenderbufferEXTFn = fn.glFramebufferRenderbufferEXTFn;
-    fn.glFramebufferRenderbufferEXTFn = Debug_glFramebufferRenderbufferEXT;
-  }
-  if (!debug_fn.glFramebufferTexture2DEXTFn) {
-    debug_fn.glFramebufferTexture2DEXTFn = fn.glFramebufferTexture2DEXTFn;
-    fn.glFramebufferTexture2DEXTFn = Debug_glFramebufferTexture2DEXT;
-  }
-  if (!debug_fn.glFramebufferTexture2DMultisampleEXTFn) {
-    debug_fn.glFramebufferTexture2DMultisampleEXTFn =
-        fn.glFramebufferTexture2DMultisampleEXTFn;
-    fn.glFramebufferTexture2DMultisampleEXTFn =
-        Debug_glFramebufferTexture2DMultisampleEXT;
-  }
-  if (!debug_fn.glFramebufferTexture2DMultisampleIMGFn) {
-    debug_fn.glFramebufferTexture2DMultisampleIMGFn =
-        fn.glFramebufferTexture2DMultisampleIMGFn;
-    fn.glFramebufferTexture2DMultisampleIMGFn =
-        Debug_glFramebufferTexture2DMultisampleIMG;
-  }
-  if (!debug_fn.glFramebufferTextureLayerFn) {
-    debug_fn.glFramebufferTextureLayerFn = fn.glFramebufferTextureLayerFn;
-    fn.glFramebufferTextureLayerFn = Debug_glFramebufferTextureLayer;
-  }
-  if (!debug_fn.glFrontFaceFn) {
-    debug_fn.glFrontFaceFn = fn.glFrontFaceFn;
-    fn.glFrontFaceFn = Debug_glFrontFace;
-  }
-  if (!debug_fn.glGenBuffersARBFn) {
-    debug_fn.glGenBuffersARBFn = fn.glGenBuffersARBFn;
-    fn.glGenBuffersARBFn = Debug_glGenBuffersARB;
-  }
-  if (!debug_fn.glGenerateMipmapEXTFn) {
-    debug_fn.glGenerateMipmapEXTFn = fn.glGenerateMipmapEXTFn;
-    fn.glGenerateMipmapEXTFn = Debug_glGenerateMipmapEXT;
-  }
-  if (!debug_fn.glGenFencesAPPLEFn) {
-    debug_fn.glGenFencesAPPLEFn = fn.glGenFencesAPPLEFn;
-    fn.glGenFencesAPPLEFn = Debug_glGenFencesAPPLE;
-  }
-  if (!debug_fn.glGenFencesNVFn) {
-    debug_fn.glGenFencesNVFn = fn.glGenFencesNVFn;
-    fn.glGenFencesNVFn = Debug_glGenFencesNV;
-  }
-  if (!debug_fn.glGenFramebuffersEXTFn) {
-    debug_fn.glGenFramebuffersEXTFn = fn.glGenFramebuffersEXTFn;
-    fn.glGenFramebuffersEXTFn = Debug_glGenFramebuffersEXT;
-  }
-  if (!debug_fn.glGenPathsNVFn) {
-    debug_fn.glGenPathsNVFn = fn.glGenPathsNVFn;
-    fn.glGenPathsNVFn = Debug_glGenPathsNV;
-  }
-  if (!debug_fn.glGenQueriesFn) {
-    debug_fn.glGenQueriesFn = fn.glGenQueriesFn;
-    fn.glGenQueriesFn = Debug_glGenQueries;
-  }
-  if (!debug_fn.glGenRenderbuffersEXTFn) {
-    debug_fn.glGenRenderbuffersEXTFn = fn.glGenRenderbuffersEXTFn;
-    fn.glGenRenderbuffersEXTFn = Debug_glGenRenderbuffersEXT;
-  }
-  if (!debug_fn.glGenSamplersFn) {
-    debug_fn.glGenSamplersFn = fn.glGenSamplersFn;
-    fn.glGenSamplersFn = Debug_glGenSamplers;
-  }
-  if (!debug_fn.glGenTexturesFn) {
-    debug_fn.glGenTexturesFn = fn.glGenTexturesFn;
-    fn.glGenTexturesFn = Debug_glGenTextures;
-  }
-  if (!debug_fn.glGenTransformFeedbacksFn) {
-    debug_fn.glGenTransformFeedbacksFn = fn.glGenTransformFeedbacksFn;
-    fn.glGenTransformFeedbacksFn = Debug_glGenTransformFeedbacks;
-  }
-  if (!debug_fn.glGenVertexArraysOESFn) {
-    debug_fn.glGenVertexArraysOESFn = fn.glGenVertexArraysOESFn;
-    fn.glGenVertexArraysOESFn = Debug_glGenVertexArraysOES;
-  }
-  if (!debug_fn.glGetActiveAttribFn) {
-    debug_fn.glGetActiveAttribFn = fn.glGetActiveAttribFn;
-    fn.glGetActiveAttribFn = Debug_glGetActiveAttrib;
-  }
-  if (!debug_fn.glGetActiveUniformFn) {
-    debug_fn.glGetActiveUniformFn = fn.glGetActiveUniformFn;
-    fn.glGetActiveUniformFn = Debug_glGetActiveUniform;
-  }
-  if (!debug_fn.glGetActiveUniformBlockivFn) {
-    debug_fn.glGetActiveUniformBlockivFn = fn.glGetActiveUniformBlockivFn;
-    fn.glGetActiveUniformBlockivFn = Debug_glGetActiveUniformBlockiv;
-  }
-  if (!debug_fn.glGetActiveUniformBlockivRobustANGLEFn) {
-    debug_fn.glGetActiveUniformBlockivRobustANGLEFn =
-        fn.glGetActiveUniformBlockivRobustANGLEFn;
-    fn.glGetActiveUniformBlockivRobustANGLEFn =
-        Debug_glGetActiveUniformBlockivRobustANGLE;
-  }
-  if (!debug_fn.glGetActiveUniformBlockNameFn) {
-    debug_fn.glGetActiveUniformBlockNameFn = fn.glGetActiveUniformBlockNameFn;
-    fn.glGetActiveUniformBlockNameFn = Debug_glGetActiveUniformBlockName;
-  }
-  if (!debug_fn.glGetActiveUniformsivFn) {
-    debug_fn.glGetActiveUniformsivFn = fn.glGetActiveUniformsivFn;
-    fn.glGetActiveUniformsivFn = Debug_glGetActiveUniformsiv;
-  }
-  if (!debug_fn.glGetAttachedShadersFn) {
-    debug_fn.glGetAttachedShadersFn = fn.glGetAttachedShadersFn;
-    fn.glGetAttachedShadersFn = Debug_glGetAttachedShaders;
-  }
-  if (!debug_fn.glGetAttribLocationFn) {
-    debug_fn.glGetAttribLocationFn = fn.glGetAttribLocationFn;
-    fn.glGetAttribLocationFn = Debug_glGetAttribLocation;
-  }
-  if (!debug_fn.glGetBooleani_vRobustANGLEFn) {
-    debug_fn.glGetBooleani_vRobustANGLEFn = fn.glGetBooleani_vRobustANGLEFn;
-    fn.glGetBooleani_vRobustANGLEFn = Debug_glGetBooleani_vRobustANGLE;
-  }
-  if (!debug_fn.glGetBooleanvFn) {
-    debug_fn.glGetBooleanvFn = fn.glGetBooleanvFn;
-    fn.glGetBooleanvFn = Debug_glGetBooleanv;
-  }
-  if (!debug_fn.glGetBooleanvRobustANGLEFn) {
-    debug_fn.glGetBooleanvRobustANGLEFn = fn.glGetBooleanvRobustANGLEFn;
-    fn.glGetBooleanvRobustANGLEFn = Debug_glGetBooleanvRobustANGLE;
-  }
-  if (!debug_fn.glGetBufferParameteri64vRobustANGLEFn) {
-    debug_fn.glGetBufferParameteri64vRobustANGLEFn =
-        fn.glGetBufferParameteri64vRobustANGLEFn;
-    fn.glGetBufferParameteri64vRobustANGLEFn =
-        Debug_glGetBufferParameteri64vRobustANGLE;
-  }
-  if (!debug_fn.glGetBufferParameterivFn) {
-    debug_fn.glGetBufferParameterivFn = fn.glGetBufferParameterivFn;
-    fn.glGetBufferParameterivFn = Debug_glGetBufferParameteriv;
-  }
-  if (!debug_fn.glGetBufferParameterivRobustANGLEFn) {
-    debug_fn.glGetBufferParameterivRobustANGLEFn =
-        fn.glGetBufferParameterivRobustANGLEFn;
-    fn.glGetBufferParameterivRobustANGLEFn =
-        Debug_glGetBufferParameterivRobustANGLE;
-  }
-  if (!debug_fn.glGetBufferPointervRobustANGLEFn) {
-    debug_fn.glGetBufferPointervRobustANGLEFn =
-        fn.glGetBufferPointervRobustANGLEFn;
-    fn.glGetBufferPointervRobustANGLEFn = Debug_glGetBufferPointervRobustANGLE;
-  }
-  if (!debug_fn.glGetDebugMessageLogFn) {
-    debug_fn.glGetDebugMessageLogFn = fn.glGetDebugMessageLogFn;
-    fn.glGetDebugMessageLogFn = Debug_glGetDebugMessageLog;
-  }
-  if (!debug_fn.glGetErrorFn) {
-    debug_fn.glGetErrorFn = fn.glGetErrorFn;
-    fn.glGetErrorFn = Debug_glGetError;
-  }
-  if (!debug_fn.glGetFenceivNVFn) {
-    debug_fn.glGetFenceivNVFn = fn.glGetFenceivNVFn;
-    fn.glGetFenceivNVFn = Debug_glGetFenceivNV;
-  }
-  if (!debug_fn.glGetFloatvFn) {
-    debug_fn.glGetFloatvFn = fn.glGetFloatvFn;
-    fn.glGetFloatvFn = Debug_glGetFloatv;
-  }
-  if (!debug_fn.glGetFloatvRobustANGLEFn) {
-    debug_fn.glGetFloatvRobustANGLEFn = fn.glGetFloatvRobustANGLEFn;
-    fn.glGetFloatvRobustANGLEFn = Debug_glGetFloatvRobustANGLE;
-  }
-  if (!debug_fn.glGetFragDataIndexFn) {
-    debug_fn.glGetFragDataIndexFn = fn.glGetFragDataIndexFn;
-    fn.glGetFragDataIndexFn = Debug_glGetFragDataIndex;
-  }
-  if (!debug_fn.glGetFragDataLocationFn) {
-    debug_fn.glGetFragDataLocationFn = fn.glGetFragDataLocationFn;
-    fn.glGetFragDataLocationFn = Debug_glGetFragDataLocation;
-  }
-  if (!debug_fn.glGetFramebufferAttachmentParameterivEXTFn) {
-    debug_fn.glGetFramebufferAttachmentParameterivEXTFn =
-        fn.glGetFramebufferAttachmentParameterivEXTFn;
-    fn.glGetFramebufferAttachmentParameterivEXTFn =
-        Debug_glGetFramebufferAttachmentParameterivEXT;
-  }
-  if (!debug_fn.glGetFramebufferAttachmentParameterivRobustANGLEFn) {
-    debug_fn.glGetFramebufferAttachmentParameterivRobustANGLEFn =
-        fn.glGetFramebufferAttachmentParameterivRobustANGLEFn;
-    fn.glGetFramebufferAttachmentParameterivRobustANGLEFn =
-        Debug_glGetFramebufferAttachmentParameterivRobustANGLE;
-  }
-  if (!debug_fn.glGetFramebufferParameterivRobustANGLEFn) {
-    debug_fn.glGetFramebufferParameterivRobustANGLEFn =
-        fn.glGetFramebufferParameterivRobustANGLEFn;
-    fn.glGetFramebufferParameterivRobustANGLEFn =
-        Debug_glGetFramebufferParameterivRobustANGLE;
-  }
-  if (!debug_fn.glGetGraphicsResetStatusARBFn) {
-    debug_fn.glGetGraphicsResetStatusARBFn = fn.glGetGraphicsResetStatusARBFn;
-    fn.glGetGraphicsResetStatusARBFn = Debug_glGetGraphicsResetStatusARB;
-  }
-  if (!debug_fn.glGetInteger64i_vFn) {
-    debug_fn.glGetInteger64i_vFn = fn.glGetInteger64i_vFn;
-    fn.glGetInteger64i_vFn = Debug_glGetInteger64i_v;
-  }
-  if (!debug_fn.glGetInteger64i_vRobustANGLEFn) {
-    debug_fn.glGetInteger64i_vRobustANGLEFn = fn.glGetInteger64i_vRobustANGLEFn;
-    fn.glGetInteger64i_vRobustANGLEFn = Debug_glGetInteger64i_vRobustANGLE;
-  }
-  if (!debug_fn.glGetInteger64vFn) {
-    debug_fn.glGetInteger64vFn = fn.glGetInteger64vFn;
-    fn.glGetInteger64vFn = Debug_glGetInteger64v;
-  }
-  if (!debug_fn.glGetInteger64vRobustANGLEFn) {
-    debug_fn.glGetInteger64vRobustANGLEFn = fn.glGetInteger64vRobustANGLEFn;
-    fn.glGetInteger64vRobustANGLEFn = Debug_glGetInteger64vRobustANGLE;
-  }
-  if (!debug_fn.glGetIntegeri_vFn) {
-    debug_fn.glGetIntegeri_vFn = fn.glGetIntegeri_vFn;
-    fn.glGetIntegeri_vFn = Debug_glGetIntegeri_v;
-  }
-  if (!debug_fn.glGetIntegeri_vRobustANGLEFn) {
-    debug_fn.glGetIntegeri_vRobustANGLEFn = fn.glGetIntegeri_vRobustANGLEFn;
-    fn.glGetIntegeri_vRobustANGLEFn = Debug_glGetIntegeri_vRobustANGLE;
-  }
-  if (!debug_fn.glGetIntegervFn) {
-    debug_fn.glGetIntegervFn = fn.glGetIntegervFn;
-    fn.glGetIntegervFn = Debug_glGetIntegerv;
-  }
-  if (!debug_fn.glGetIntegervRobustANGLEFn) {
-    debug_fn.glGetIntegervRobustANGLEFn = fn.glGetIntegervRobustANGLEFn;
-    fn.glGetIntegervRobustANGLEFn = Debug_glGetIntegervRobustANGLE;
-  }
-  if (!debug_fn.glGetInternalformativFn) {
-    debug_fn.glGetInternalformativFn = fn.glGetInternalformativFn;
-    fn.glGetInternalformativFn = Debug_glGetInternalformativ;
-  }
-  if (!debug_fn.glGetInternalformativRobustANGLEFn) {
-    debug_fn.glGetInternalformativRobustANGLEFn =
-        fn.glGetInternalformativRobustANGLEFn;
-    fn.glGetInternalformativRobustANGLEFn =
-        Debug_glGetInternalformativRobustANGLE;
-  }
-  if (!debug_fn.glGetMultisamplefvRobustANGLEFn) {
-    debug_fn.glGetMultisamplefvRobustANGLEFn =
-        fn.glGetMultisamplefvRobustANGLEFn;
-    fn.glGetMultisamplefvRobustANGLEFn = Debug_glGetMultisamplefvRobustANGLE;
-  }
-  if (!debug_fn.glGetnUniformfvRobustANGLEFn) {
-    debug_fn.glGetnUniformfvRobustANGLEFn = fn.glGetnUniformfvRobustANGLEFn;
-    fn.glGetnUniformfvRobustANGLEFn = Debug_glGetnUniformfvRobustANGLE;
-  }
-  if (!debug_fn.glGetnUniformivRobustANGLEFn) {
-    debug_fn.glGetnUniformivRobustANGLEFn = fn.glGetnUniformivRobustANGLEFn;
-    fn.glGetnUniformivRobustANGLEFn = Debug_glGetnUniformivRobustANGLE;
-  }
-  if (!debug_fn.glGetnUniformuivRobustANGLEFn) {
-    debug_fn.glGetnUniformuivRobustANGLEFn = fn.glGetnUniformuivRobustANGLEFn;
-    fn.glGetnUniformuivRobustANGLEFn = Debug_glGetnUniformuivRobustANGLE;
-  }
-  if (!debug_fn.glGetObjectLabelFn) {
-    debug_fn.glGetObjectLabelFn = fn.glGetObjectLabelFn;
-    fn.glGetObjectLabelFn = Debug_glGetObjectLabel;
-  }
-  if (!debug_fn.glGetObjectPtrLabelFn) {
-    debug_fn.glGetObjectPtrLabelFn = fn.glGetObjectPtrLabelFn;
-    fn.glGetObjectPtrLabelFn = Debug_glGetObjectPtrLabel;
-  }
-  if (!debug_fn.glGetPointervFn) {
-    debug_fn.glGetPointervFn = fn.glGetPointervFn;
-    fn.glGetPointervFn = Debug_glGetPointerv;
-  }
-  if (!debug_fn.glGetPointervRobustANGLERobustANGLEFn) {
-    debug_fn.glGetPointervRobustANGLERobustANGLEFn =
-        fn.glGetPointervRobustANGLERobustANGLEFn;
-    fn.glGetPointervRobustANGLERobustANGLEFn =
-        Debug_glGetPointervRobustANGLERobustANGLE;
-  }
-  if (!debug_fn.glGetProgramBinaryFn) {
-    debug_fn.glGetProgramBinaryFn = fn.glGetProgramBinaryFn;
-    fn.glGetProgramBinaryFn = Debug_glGetProgramBinary;
-  }
-  if (!debug_fn.glGetProgramInfoLogFn) {
-    debug_fn.glGetProgramInfoLogFn = fn.glGetProgramInfoLogFn;
-    fn.glGetProgramInfoLogFn = Debug_glGetProgramInfoLog;
-  }
-  if (!debug_fn.glGetProgramInterfaceivFn) {
-    debug_fn.glGetProgramInterfaceivFn = fn.glGetProgramInterfaceivFn;
-    fn.glGetProgramInterfaceivFn = Debug_glGetProgramInterfaceiv;
-  }
-  if (!debug_fn.glGetProgramInterfaceivRobustANGLEFn) {
-    debug_fn.glGetProgramInterfaceivRobustANGLEFn =
-        fn.glGetProgramInterfaceivRobustANGLEFn;
-    fn.glGetProgramInterfaceivRobustANGLEFn =
-        Debug_glGetProgramInterfaceivRobustANGLE;
-  }
-  if (!debug_fn.glGetProgramivFn) {
-    debug_fn.glGetProgramivFn = fn.glGetProgramivFn;
-    fn.glGetProgramivFn = Debug_glGetProgramiv;
-  }
-  if (!debug_fn.glGetProgramivRobustANGLEFn) {
-    debug_fn.glGetProgramivRobustANGLEFn = fn.glGetProgramivRobustANGLEFn;
-    fn.glGetProgramivRobustANGLEFn = Debug_glGetProgramivRobustANGLE;
-  }
-  if (!debug_fn.glGetProgramResourceivFn) {
-    debug_fn.glGetProgramResourceivFn = fn.glGetProgramResourceivFn;
-    fn.glGetProgramResourceivFn = Debug_glGetProgramResourceiv;
-  }
-  if (!debug_fn.glGetProgramResourceLocationFn) {
-    debug_fn.glGetProgramResourceLocationFn = fn.glGetProgramResourceLocationFn;
-    fn.glGetProgramResourceLocationFn = Debug_glGetProgramResourceLocation;
-  }
-  if (!debug_fn.glGetProgramResourceNameFn) {
-    debug_fn.glGetProgramResourceNameFn = fn.glGetProgramResourceNameFn;
-    fn.glGetProgramResourceNameFn = Debug_glGetProgramResourceName;
-  }
-  if (!debug_fn.glGetQueryivFn) {
-    debug_fn.glGetQueryivFn = fn.glGetQueryivFn;
-    fn.glGetQueryivFn = Debug_glGetQueryiv;
-  }
-  if (!debug_fn.glGetQueryivRobustANGLEFn) {
-    debug_fn.glGetQueryivRobustANGLEFn = fn.glGetQueryivRobustANGLEFn;
-    fn.glGetQueryivRobustANGLEFn = Debug_glGetQueryivRobustANGLE;
-  }
-  if (!debug_fn.glGetQueryObjecti64vFn) {
-    debug_fn.glGetQueryObjecti64vFn = fn.glGetQueryObjecti64vFn;
-    fn.glGetQueryObjecti64vFn = Debug_glGetQueryObjecti64v;
-  }
-  if (!debug_fn.glGetQueryObjecti64vRobustANGLEFn) {
-    debug_fn.glGetQueryObjecti64vRobustANGLEFn =
-        fn.glGetQueryObjecti64vRobustANGLEFn;
-    fn.glGetQueryObjecti64vRobustANGLEFn =
-        Debug_glGetQueryObjecti64vRobustANGLE;
-  }
-  if (!debug_fn.glGetQueryObjectivFn) {
-    debug_fn.glGetQueryObjectivFn = fn.glGetQueryObjectivFn;
-    fn.glGetQueryObjectivFn = Debug_glGetQueryObjectiv;
-  }
-  if (!debug_fn.glGetQueryObjectivRobustANGLEFn) {
-    debug_fn.glGetQueryObjectivRobustANGLEFn =
-        fn.glGetQueryObjectivRobustANGLEFn;
-    fn.glGetQueryObjectivRobustANGLEFn = Debug_glGetQueryObjectivRobustANGLE;
-  }
-  if (!debug_fn.glGetQueryObjectui64vFn) {
-    debug_fn.glGetQueryObjectui64vFn = fn.glGetQueryObjectui64vFn;
-    fn.glGetQueryObjectui64vFn = Debug_glGetQueryObjectui64v;
-  }
-  if (!debug_fn.glGetQueryObjectui64vRobustANGLEFn) {
-    debug_fn.glGetQueryObjectui64vRobustANGLEFn =
-        fn.glGetQueryObjectui64vRobustANGLEFn;
-    fn.glGetQueryObjectui64vRobustANGLEFn =
-        Debug_glGetQueryObjectui64vRobustANGLE;
-  }
-  if (!debug_fn.glGetQueryObjectuivFn) {
-    debug_fn.glGetQueryObjectuivFn = fn.glGetQueryObjectuivFn;
-    fn.glGetQueryObjectuivFn = Debug_glGetQueryObjectuiv;
-  }
-  if (!debug_fn.glGetQueryObjectuivRobustANGLEFn) {
-    debug_fn.glGetQueryObjectuivRobustANGLEFn =
-        fn.glGetQueryObjectuivRobustANGLEFn;
-    fn.glGetQueryObjectuivRobustANGLEFn = Debug_glGetQueryObjectuivRobustANGLE;
-  }
-  if (!debug_fn.glGetRenderbufferParameterivEXTFn) {
-    debug_fn.glGetRenderbufferParameterivEXTFn =
-        fn.glGetRenderbufferParameterivEXTFn;
-    fn.glGetRenderbufferParameterivEXTFn =
-        Debug_glGetRenderbufferParameterivEXT;
-  }
-  if (!debug_fn.glGetRenderbufferParameterivRobustANGLEFn) {
-    debug_fn.glGetRenderbufferParameterivRobustANGLEFn =
-        fn.glGetRenderbufferParameterivRobustANGLEFn;
-    fn.glGetRenderbufferParameterivRobustANGLEFn =
-        Debug_glGetRenderbufferParameterivRobustANGLE;
-  }
-  if (!debug_fn.glGetSamplerParameterfvFn) {
-    debug_fn.glGetSamplerParameterfvFn = fn.glGetSamplerParameterfvFn;
-    fn.glGetSamplerParameterfvFn = Debug_glGetSamplerParameterfv;
-  }
-  if (!debug_fn.glGetSamplerParameterfvRobustANGLEFn) {
-    debug_fn.glGetSamplerParameterfvRobustANGLEFn =
-        fn.glGetSamplerParameterfvRobustANGLEFn;
-    fn.glGetSamplerParameterfvRobustANGLEFn =
-        Debug_glGetSamplerParameterfvRobustANGLE;
-  }
-  if (!debug_fn.glGetSamplerParameterIivRobustANGLEFn) {
-    debug_fn.glGetSamplerParameterIivRobustANGLEFn =
-        fn.glGetSamplerParameterIivRobustANGLEFn;
-    fn.glGetSamplerParameterIivRobustANGLEFn =
-        Debug_glGetSamplerParameterIivRobustANGLE;
-  }
-  if (!debug_fn.glGetSamplerParameterIuivRobustANGLEFn) {
-    debug_fn.glGetSamplerParameterIuivRobustANGLEFn =
-        fn.glGetSamplerParameterIuivRobustANGLEFn;
-    fn.glGetSamplerParameterIuivRobustANGLEFn =
-        Debug_glGetSamplerParameterIuivRobustANGLE;
-  }
-  if (!debug_fn.glGetSamplerParameterivFn) {
-    debug_fn.glGetSamplerParameterivFn = fn.glGetSamplerParameterivFn;
-    fn.glGetSamplerParameterivFn = Debug_glGetSamplerParameteriv;
-  }
-  if (!debug_fn.glGetSamplerParameterivRobustANGLEFn) {
-    debug_fn.glGetSamplerParameterivRobustANGLEFn =
-        fn.glGetSamplerParameterivRobustANGLEFn;
-    fn.glGetSamplerParameterivRobustANGLEFn =
-        Debug_glGetSamplerParameterivRobustANGLE;
-  }
-  if (!debug_fn.glGetShaderInfoLogFn) {
-    debug_fn.glGetShaderInfoLogFn = fn.glGetShaderInfoLogFn;
-    fn.glGetShaderInfoLogFn = Debug_glGetShaderInfoLog;
-  }
-  if (!debug_fn.glGetShaderivFn) {
-    debug_fn.glGetShaderivFn = fn.glGetShaderivFn;
-    fn.glGetShaderivFn = Debug_glGetShaderiv;
-  }
-  if (!debug_fn.glGetShaderivRobustANGLEFn) {
-    debug_fn.glGetShaderivRobustANGLEFn = fn.glGetShaderivRobustANGLEFn;
-    fn.glGetShaderivRobustANGLEFn = Debug_glGetShaderivRobustANGLE;
-  }
-  if (!debug_fn.glGetShaderPrecisionFormatFn) {
-    debug_fn.glGetShaderPrecisionFormatFn = fn.glGetShaderPrecisionFormatFn;
-    fn.glGetShaderPrecisionFormatFn = Debug_glGetShaderPrecisionFormat;
-  }
-  if (!debug_fn.glGetShaderSourceFn) {
-    debug_fn.glGetShaderSourceFn = fn.glGetShaderSourceFn;
-    fn.glGetShaderSourceFn = Debug_glGetShaderSource;
-  }
-  if (!debug_fn.glGetStringFn) {
-    debug_fn.glGetStringFn = fn.glGetStringFn;
-    fn.glGetStringFn = Debug_glGetString;
-  }
-  if (!debug_fn.glGetStringiFn) {
-    debug_fn.glGetStringiFn = fn.glGetStringiFn;
-    fn.glGetStringiFn = Debug_glGetStringi;
-  }
-  if (!debug_fn.glGetSyncivFn) {
-    debug_fn.glGetSyncivFn = fn.glGetSyncivFn;
-    fn.glGetSyncivFn = Debug_glGetSynciv;
-  }
-  if (!debug_fn.glGetTexLevelParameterfvFn) {
-    debug_fn.glGetTexLevelParameterfvFn = fn.glGetTexLevelParameterfvFn;
-    fn.glGetTexLevelParameterfvFn = Debug_glGetTexLevelParameterfv;
-  }
-  if (!debug_fn.glGetTexLevelParameterfvRobustANGLEFn) {
-    debug_fn.glGetTexLevelParameterfvRobustANGLEFn =
-        fn.glGetTexLevelParameterfvRobustANGLEFn;
-    fn.glGetTexLevelParameterfvRobustANGLEFn =
-        Debug_glGetTexLevelParameterfvRobustANGLE;
-  }
-  if (!debug_fn.glGetTexLevelParameterivFn) {
-    debug_fn.glGetTexLevelParameterivFn = fn.glGetTexLevelParameterivFn;
-    fn.glGetTexLevelParameterivFn = Debug_glGetTexLevelParameteriv;
-  }
-  if (!debug_fn.glGetTexLevelParameterivRobustANGLEFn) {
-    debug_fn.glGetTexLevelParameterivRobustANGLEFn =
-        fn.glGetTexLevelParameterivRobustANGLEFn;
-    fn.glGetTexLevelParameterivRobustANGLEFn =
-        Debug_glGetTexLevelParameterivRobustANGLE;
-  }
-  if (!debug_fn.glGetTexParameterfvFn) {
-    debug_fn.glGetTexParameterfvFn = fn.glGetTexParameterfvFn;
-    fn.glGetTexParameterfvFn = Debug_glGetTexParameterfv;
-  }
-  if (!debug_fn.glGetTexParameterfvRobustANGLEFn) {
-    debug_fn.glGetTexParameterfvRobustANGLEFn =
-        fn.glGetTexParameterfvRobustANGLEFn;
-    fn.glGetTexParameterfvRobustANGLEFn = Debug_glGetTexParameterfvRobustANGLE;
-  }
-  if (!debug_fn.glGetTexParameterIivRobustANGLEFn) {
-    debug_fn.glGetTexParameterIivRobustANGLEFn =
-        fn.glGetTexParameterIivRobustANGLEFn;
-    fn.glGetTexParameterIivRobustANGLEFn =
-        Debug_glGetTexParameterIivRobustANGLE;
-  }
-  if (!debug_fn.glGetTexParameterIuivRobustANGLEFn) {
-    debug_fn.glGetTexParameterIuivRobustANGLEFn =
-        fn.glGetTexParameterIuivRobustANGLEFn;
-    fn.glGetTexParameterIuivRobustANGLEFn =
-        Debug_glGetTexParameterIuivRobustANGLE;
-  }
-  if (!debug_fn.glGetTexParameterivFn) {
-    debug_fn.glGetTexParameterivFn = fn.glGetTexParameterivFn;
-    fn.glGetTexParameterivFn = Debug_glGetTexParameteriv;
-  }
-  if (!debug_fn.glGetTexParameterivRobustANGLEFn) {
-    debug_fn.glGetTexParameterivRobustANGLEFn =
-        fn.glGetTexParameterivRobustANGLEFn;
-    fn.glGetTexParameterivRobustANGLEFn = Debug_glGetTexParameterivRobustANGLE;
-  }
-  if (!debug_fn.glGetTransformFeedbackVaryingFn) {
-    debug_fn.glGetTransformFeedbackVaryingFn =
-        fn.glGetTransformFeedbackVaryingFn;
-    fn.glGetTransformFeedbackVaryingFn = Debug_glGetTransformFeedbackVarying;
-  }
-  if (!debug_fn.glGetTranslatedShaderSourceANGLEFn) {
-    debug_fn.glGetTranslatedShaderSourceANGLEFn =
-        fn.glGetTranslatedShaderSourceANGLEFn;
-    fn.glGetTranslatedShaderSourceANGLEFn =
-        Debug_glGetTranslatedShaderSourceANGLE;
-  }
-  if (!debug_fn.glGetUniformBlockIndexFn) {
-    debug_fn.glGetUniformBlockIndexFn = fn.glGetUniformBlockIndexFn;
-    fn.glGetUniformBlockIndexFn = Debug_glGetUniformBlockIndex;
-  }
-  if (!debug_fn.glGetUniformfvFn) {
-    debug_fn.glGetUniformfvFn = fn.glGetUniformfvFn;
-    fn.glGetUniformfvFn = Debug_glGetUniformfv;
-  }
-  if (!debug_fn.glGetUniformfvRobustANGLEFn) {
-    debug_fn.glGetUniformfvRobustANGLEFn = fn.glGetUniformfvRobustANGLEFn;
-    fn.glGetUniformfvRobustANGLEFn = Debug_glGetUniformfvRobustANGLE;
-  }
-  if (!debug_fn.glGetUniformIndicesFn) {
-    debug_fn.glGetUniformIndicesFn = fn.glGetUniformIndicesFn;
-    fn.glGetUniformIndicesFn = Debug_glGetUniformIndices;
-  }
-  if (!debug_fn.glGetUniformivFn) {
-    debug_fn.glGetUniformivFn = fn.glGetUniformivFn;
-    fn.glGetUniformivFn = Debug_glGetUniformiv;
-  }
-  if (!debug_fn.glGetUniformivRobustANGLEFn) {
-    debug_fn.glGetUniformivRobustANGLEFn = fn.glGetUniformivRobustANGLEFn;
-    fn.glGetUniformivRobustANGLEFn = Debug_glGetUniformivRobustANGLE;
-  }
-  if (!debug_fn.glGetUniformLocationFn) {
-    debug_fn.glGetUniformLocationFn = fn.glGetUniformLocationFn;
-    fn.glGetUniformLocationFn = Debug_glGetUniformLocation;
-  }
-  if (!debug_fn.glGetUniformuivFn) {
-    debug_fn.glGetUniformuivFn = fn.glGetUniformuivFn;
-    fn.glGetUniformuivFn = Debug_glGetUniformuiv;
-  }
-  if (!debug_fn.glGetUniformuivRobustANGLEFn) {
-    debug_fn.glGetUniformuivRobustANGLEFn = fn.glGetUniformuivRobustANGLEFn;
-    fn.glGetUniformuivRobustANGLEFn = Debug_glGetUniformuivRobustANGLE;
-  }
-  if (!debug_fn.glGetVertexAttribfvFn) {
-    debug_fn.glGetVertexAttribfvFn = fn.glGetVertexAttribfvFn;
-    fn.glGetVertexAttribfvFn = Debug_glGetVertexAttribfv;
-  }
-  if (!debug_fn.glGetVertexAttribfvRobustANGLEFn) {
-    debug_fn.glGetVertexAttribfvRobustANGLEFn =
-        fn.glGetVertexAttribfvRobustANGLEFn;
-    fn.glGetVertexAttribfvRobustANGLEFn = Debug_glGetVertexAttribfvRobustANGLE;
-  }
-  if (!debug_fn.glGetVertexAttribIivRobustANGLEFn) {
-    debug_fn.glGetVertexAttribIivRobustANGLEFn =
-        fn.glGetVertexAttribIivRobustANGLEFn;
-    fn.glGetVertexAttribIivRobustANGLEFn =
-        Debug_glGetVertexAttribIivRobustANGLE;
-  }
-  if (!debug_fn.glGetVertexAttribIuivRobustANGLEFn) {
-    debug_fn.glGetVertexAttribIuivRobustANGLEFn =
-        fn.glGetVertexAttribIuivRobustANGLEFn;
-    fn.glGetVertexAttribIuivRobustANGLEFn =
-        Debug_glGetVertexAttribIuivRobustANGLE;
-  }
-  if (!debug_fn.glGetVertexAttribivFn) {
-    debug_fn.glGetVertexAttribivFn = fn.glGetVertexAttribivFn;
-    fn.glGetVertexAttribivFn = Debug_glGetVertexAttribiv;
-  }
-  if (!debug_fn.glGetVertexAttribivRobustANGLEFn) {
-    debug_fn.glGetVertexAttribivRobustANGLEFn =
-        fn.glGetVertexAttribivRobustANGLEFn;
-    fn.glGetVertexAttribivRobustANGLEFn = Debug_glGetVertexAttribivRobustANGLE;
-  }
-  if (!debug_fn.glGetVertexAttribPointervFn) {
-    debug_fn.glGetVertexAttribPointervFn = fn.glGetVertexAttribPointervFn;
-    fn.glGetVertexAttribPointervFn = Debug_glGetVertexAttribPointerv;
-  }
-  if (!debug_fn.glGetVertexAttribPointervRobustANGLEFn) {
-    debug_fn.glGetVertexAttribPointervRobustANGLEFn =
-        fn.glGetVertexAttribPointervRobustANGLEFn;
-    fn.glGetVertexAttribPointervRobustANGLEFn =
-        Debug_glGetVertexAttribPointervRobustANGLE;
-  }
-  if (!debug_fn.glHintFn) {
-    debug_fn.glHintFn = fn.glHintFn;
-    fn.glHintFn = Debug_glHint;
-  }
-  if (!debug_fn.glInsertEventMarkerEXTFn) {
-    debug_fn.glInsertEventMarkerEXTFn = fn.glInsertEventMarkerEXTFn;
-    fn.glInsertEventMarkerEXTFn = Debug_glInsertEventMarkerEXT;
-  }
-  if (!debug_fn.glInvalidateFramebufferFn) {
-    debug_fn.glInvalidateFramebufferFn = fn.glInvalidateFramebufferFn;
-    fn.glInvalidateFramebufferFn = Debug_glInvalidateFramebuffer;
-  }
-  if (!debug_fn.glInvalidateSubFramebufferFn) {
-    debug_fn.glInvalidateSubFramebufferFn = fn.glInvalidateSubFramebufferFn;
-    fn.glInvalidateSubFramebufferFn = Debug_glInvalidateSubFramebuffer;
-  }
-  if (!debug_fn.glIsBufferFn) {
-    debug_fn.glIsBufferFn = fn.glIsBufferFn;
-    fn.glIsBufferFn = Debug_glIsBuffer;
-  }
-  if (!debug_fn.glIsEnabledFn) {
-    debug_fn.glIsEnabledFn = fn.glIsEnabledFn;
-    fn.glIsEnabledFn = Debug_glIsEnabled;
-  }
-  if (!debug_fn.glIsFenceAPPLEFn) {
-    debug_fn.glIsFenceAPPLEFn = fn.glIsFenceAPPLEFn;
-    fn.glIsFenceAPPLEFn = Debug_glIsFenceAPPLE;
-  }
-  if (!debug_fn.glIsFenceNVFn) {
-    debug_fn.glIsFenceNVFn = fn.glIsFenceNVFn;
-    fn.glIsFenceNVFn = Debug_glIsFenceNV;
-  }
-  if (!debug_fn.glIsFramebufferEXTFn) {
-    debug_fn.glIsFramebufferEXTFn = fn.glIsFramebufferEXTFn;
-    fn.glIsFramebufferEXTFn = Debug_glIsFramebufferEXT;
-  }
-  if (!debug_fn.glIsPathNVFn) {
-    debug_fn.glIsPathNVFn = fn.glIsPathNVFn;
-    fn.glIsPathNVFn = Debug_glIsPathNV;
-  }
-  if (!debug_fn.glIsProgramFn) {
-    debug_fn.glIsProgramFn = fn.glIsProgramFn;
-    fn.glIsProgramFn = Debug_glIsProgram;
-  }
-  if (!debug_fn.glIsQueryFn) {
-    debug_fn.glIsQueryFn = fn.glIsQueryFn;
-    fn.glIsQueryFn = Debug_glIsQuery;
-  }
-  if (!debug_fn.glIsRenderbufferEXTFn) {
-    debug_fn.glIsRenderbufferEXTFn = fn.glIsRenderbufferEXTFn;
-    fn.glIsRenderbufferEXTFn = Debug_glIsRenderbufferEXT;
-  }
-  if (!debug_fn.glIsSamplerFn) {
-    debug_fn.glIsSamplerFn = fn.glIsSamplerFn;
-    fn.glIsSamplerFn = Debug_glIsSampler;
-  }
-  if (!debug_fn.glIsShaderFn) {
-    debug_fn.glIsShaderFn = fn.glIsShaderFn;
-    fn.glIsShaderFn = Debug_glIsShader;
-  }
-  if (!debug_fn.glIsSyncFn) {
-    debug_fn.glIsSyncFn = fn.glIsSyncFn;
-    fn.glIsSyncFn = Debug_glIsSync;
-  }
-  if (!debug_fn.glIsTextureFn) {
-    debug_fn.glIsTextureFn = fn.glIsTextureFn;
-    fn.glIsTextureFn = Debug_glIsTexture;
-  }
-  if (!debug_fn.glIsTransformFeedbackFn) {
-    debug_fn.glIsTransformFeedbackFn = fn.glIsTransformFeedbackFn;
-    fn.glIsTransformFeedbackFn = Debug_glIsTransformFeedback;
-  }
-  if (!debug_fn.glIsVertexArrayOESFn) {
-    debug_fn.glIsVertexArrayOESFn = fn.glIsVertexArrayOESFn;
-    fn.glIsVertexArrayOESFn = Debug_glIsVertexArrayOES;
-  }
-  if (!debug_fn.glLineWidthFn) {
-    debug_fn.glLineWidthFn = fn.glLineWidthFn;
-    fn.glLineWidthFn = Debug_glLineWidth;
-  }
-  if (!debug_fn.glLinkProgramFn) {
-    debug_fn.glLinkProgramFn = fn.glLinkProgramFn;
-    fn.glLinkProgramFn = Debug_glLinkProgram;
-  }
-  if (!debug_fn.glMapBufferFn) {
-    debug_fn.glMapBufferFn = fn.glMapBufferFn;
-    fn.glMapBufferFn = Debug_glMapBuffer;
-  }
-  if (!debug_fn.glMapBufferRangeFn) {
-    debug_fn.glMapBufferRangeFn = fn.glMapBufferRangeFn;
-    fn.glMapBufferRangeFn = Debug_glMapBufferRange;
-  }
-  if (!debug_fn.glMatrixLoadfEXTFn) {
-    debug_fn.glMatrixLoadfEXTFn = fn.glMatrixLoadfEXTFn;
-    fn.glMatrixLoadfEXTFn = Debug_glMatrixLoadfEXT;
-  }
-  if (!debug_fn.glMatrixLoadIdentityEXTFn) {
-    debug_fn.glMatrixLoadIdentityEXTFn = fn.glMatrixLoadIdentityEXTFn;
-    fn.glMatrixLoadIdentityEXTFn = Debug_glMatrixLoadIdentityEXT;
-  }
-  if (!debug_fn.glMemoryBarrierEXTFn) {
-    debug_fn.glMemoryBarrierEXTFn = fn.glMemoryBarrierEXTFn;
-    fn.glMemoryBarrierEXTFn = Debug_glMemoryBarrierEXT;
-  }
-  if (!debug_fn.glObjectLabelFn) {
-    debug_fn.glObjectLabelFn = fn.glObjectLabelFn;
-    fn.glObjectLabelFn = Debug_glObjectLabel;
-  }
-  if (!debug_fn.glObjectPtrLabelFn) {
-    debug_fn.glObjectPtrLabelFn = fn.glObjectPtrLabelFn;
-    fn.glObjectPtrLabelFn = Debug_glObjectPtrLabel;
-  }
-  if (!debug_fn.glPathCommandsNVFn) {
-    debug_fn.glPathCommandsNVFn = fn.glPathCommandsNVFn;
-    fn.glPathCommandsNVFn = Debug_glPathCommandsNV;
-  }
-  if (!debug_fn.glPathParameterfNVFn) {
-    debug_fn.glPathParameterfNVFn = fn.glPathParameterfNVFn;
-    fn.glPathParameterfNVFn = Debug_glPathParameterfNV;
-  }
-  if (!debug_fn.glPathParameteriNVFn) {
-    debug_fn.glPathParameteriNVFn = fn.glPathParameteriNVFn;
-    fn.glPathParameteriNVFn = Debug_glPathParameteriNV;
-  }
-  if (!debug_fn.glPathStencilFuncNVFn) {
-    debug_fn.glPathStencilFuncNVFn = fn.glPathStencilFuncNVFn;
-    fn.glPathStencilFuncNVFn = Debug_glPathStencilFuncNV;
-  }
-  if (!debug_fn.glPauseTransformFeedbackFn) {
-    debug_fn.glPauseTransformFeedbackFn = fn.glPauseTransformFeedbackFn;
-    fn.glPauseTransformFeedbackFn = Debug_glPauseTransformFeedback;
-  }
-  if (!debug_fn.glPixelStoreiFn) {
-    debug_fn.glPixelStoreiFn = fn.glPixelStoreiFn;
-    fn.glPixelStoreiFn = Debug_glPixelStorei;
-  }
-  if (!debug_fn.glPointParameteriFn) {
-    debug_fn.glPointParameteriFn = fn.glPointParameteriFn;
-    fn.glPointParameteriFn = Debug_glPointParameteri;
-  }
-  if (!debug_fn.glPolygonOffsetFn) {
-    debug_fn.glPolygonOffsetFn = fn.glPolygonOffsetFn;
-    fn.glPolygonOffsetFn = Debug_glPolygonOffset;
-  }
-  if (!debug_fn.glPopDebugGroupFn) {
-    debug_fn.glPopDebugGroupFn = fn.glPopDebugGroupFn;
-    fn.glPopDebugGroupFn = Debug_glPopDebugGroup;
-  }
-  if (!debug_fn.glPopGroupMarkerEXTFn) {
-    debug_fn.glPopGroupMarkerEXTFn = fn.glPopGroupMarkerEXTFn;
-    fn.glPopGroupMarkerEXTFn = Debug_glPopGroupMarkerEXT;
-  }
-  if (!debug_fn.glPrimitiveRestartIndexFn) {
-    debug_fn.glPrimitiveRestartIndexFn = fn.glPrimitiveRestartIndexFn;
-    fn.glPrimitiveRestartIndexFn = Debug_glPrimitiveRestartIndex;
-  }
-  if (!debug_fn.glProgramBinaryFn) {
-    debug_fn.glProgramBinaryFn = fn.glProgramBinaryFn;
-    fn.glProgramBinaryFn = Debug_glProgramBinary;
-  }
-  if (!debug_fn.glProgramParameteriFn) {
-    debug_fn.glProgramParameteriFn = fn.glProgramParameteriFn;
-    fn.glProgramParameteriFn = Debug_glProgramParameteri;
-  }
-  if (!debug_fn.glProgramPathFragmentInputGenNVFn) {
-    debug_fn.glProgramPathFragmentInputGenNVFn =
-        fn.glProgramPathFragmentInputGenNVFn;
-    fn.glProgramPathFragmentInputGenNVFn =
-        Debug_glProgramPathFragmentInputGenNV;
-  }
-  if (!debug_fn.glPushDebugGroupFn) {
-    debug_fn.glPushDebugGroupFn = fn.glPushDebugGroupFn;
-    fn.glPushDebugGroupFn = Debug_glPushDebugGroup;
-  }
-  if (!debug_fn.glPushGroupMarkerEXTFn) {
-    debug_fn.glPushGroupMarkerEXTFn = fn.glPushGroupMarkerEXTFn;
-    fn.glPushGroupMarkerEXTFn = Debug_glPushGroupMarkerEXT;
-  }
-  if (!debug_fn.glQueryCounterFn) {
-    debug_fn.glQueryCounterFn = fn.glQueryCounterFn;
-    fn.glQueryCounterFn = Debug_glQueryCounter;
-  }
-  if (!debug_fn.glReadBufferFn) {
-    debug_fn.glReadBufferFn = fn.glReadBufferFn;
-    fn.glReadBufferFn = Debug_glReadBuffer;
-  }
-  if (!debug_fn.glReadnPixelsRobustANGLEFn) {
-    debug_fn.glReadnPixelsRobustANGLEFn = fn.glReadnPixelsRobustANGLEFn;
-    fn.glReadnPixelsRobustANGLEFn = Debug_glReadnPixelsRobustANGLE;
-  }
-  if (!debug_fn.glReadPixelsFn) {
-    debug_fn.glReadPixelsFn = fn.glReadPixelsFn;
-    fn.glReadPixelsFn = Debug_glReadPixels;
-  }
-  if (!debug_fn.glReadPixelsRobustANGLEFn) {
-    debug_fn.glReadPixelsRobustANGLEFn = fn.glReadPixelsRobustANGLEFn;
-    fn.glReadPixelsRobustANGLEFn = Debug_glReadPixelsRobustANGLE;
-  }
-  if (!debug_fn.glReleaseShaderCompilerFn) {
-    debug_fn.glReleaseShaderCompilerFn = fn.glReleaseShaderCompilerFn;
-    fn.glReleaseShaderCompilerFn = Debug_glReleaseShaderCompiler;
-  }
-  if (!debug_fn.glRenderbufferStorageEXTFn) {
-    debug_fn.glRenderbufferStorageEXTFn = fn.glRenderbufferStorageEXTFn;
-    fn.glRenderbufferStorageEXTFn = Debug_glRenderbufferStorageEXT;
-  }
-  if (!debug_fn.glRenderbufferStorageMultisampleFn) {
-    debug_fn.glRenderbufferStorageMultisampleFn =
-        fn.glRenderbufferStorageMultisampleFn;
-    fn.glRenderbufferStorageMultisampleFn =
-        Debug_glRenderbufferStorageMultisample;
-  }
-  if (!debug_fn.glRenderbufferStorageMultisampleANGLEFn) {
-    debug_fn.glRenderbufferStorageMultisampleANGLEFn =
-        fn.glRenderbufferStorageMultisampleANGLEFn;
-    fn.glRenderbufferStorageMultisampleANGLEFn =
-        Debug_glRenderbufferStorageMultisampleANGLE;
-  }
-  if (!debug_fn.glRenderbufferStorageMultisampleEXTFn) {
-    debug_fn.glRenderbufferStorageMultisampleEXTFn =
-        fn.glRenderbufferStorageMultisampleEXTFn;
-    fn.glRenderbufferStorageMultisampleEXTFn =
-        Debug_glRenderbufferStorageMultisampleEXT;
-  }
-  if (!debug_fn.glRenderbufferStorageMultisampleIMGFn) {
-    debug_fn.glRenderbufferStorageMultisampleIMGFn =
-        fn.glRenderbufferStorageMultisampleIMGFn;
-    fn.glRenderbufferStorageMultisampleIMGFn =
-        Debug_glRenderbufferStorageMultisampleIMG;
-  }
-  if (!debug_fn.glResumeTransformFeedbackFn) {
-    debug_fn.glResumeTransformFeedbackFn = fn.glResumeTransformFeedbackFn;
-    fn.glResumeTransformFeedbackFn = Debug_glResumeTransformFeedback;
-  }
-  if (!debug_fn.glSampleCoverageFn) {
-    debug_fn.glSampleCoverageFn = fn.glSampleCoverageFn;
-    fn.glSampleCoverageFn = Debug_glSampleCoverage;
-  }
-  if (!debug_fn.glSamplerParameterfFn) {
-    debug_fn.glSamplerParameterfFn = fn.glSamplerParameterfFn;
-    fn.glSamplerParameterfFn = Debug_glSamplerParameterf;
-  }
-  if (!debug_fn.glSamplerParameterfvFn) {
-    debug_fn.glSamplerParameterfvFn = fn.glSamplerParameterfvFn;
-    fn.glSamplerParameterfvFn = Debug_glSamplerParameterfv;
-  }
-  if (!debug_fn.glSamplerParameterfvRobustANGLEFn) {
-    debug_fn.glSamplerParameterfvRobustANGLEFn =
-        fn.glSamplerParameterfvRobustANGLEFn;
-    fn.glSamplerParameterfvRobustANGLEFn =
-        Debug_glSamplerParameterfvRobustANGLE;
-  }
-  if (!debug_fn.glSamplerParameteriFn) {
-    debug_fn.glSamplerParameteriFn = fn.glSamplerParameteriFn;
-    fn.glSamplerParameteriFn = Debug_glSamplerParameteri;
-  }
-  if (!debug_fn.glSamplerParameterIivRobustANGLEFn) {
-    debug_fn.glSamplerParameterIivRobustANGLEFn =
-        fn.glSamplerParameterIivRobustANGLEFn;
-    fn.glSamplerParameterIivRobustANGLEFn =
-        Debug_glSamplerParameterIivRobustANGLE;
-  }
-  if (!debug_fn.glSamplerParameterIuivRobustANGLEFn) {
-    debug_fn.glSamplerParameterIuivRobustANGLEFn =
-        fn.glSamplerParameterIuivRobustANGLEFn;
-    fn.glSamplerParameterIuivRobustANGLEFn =
-        Debug_glSamplerParameterIuivRobustANGLE;
-  }
-  if (!debug_fn.glSamplerParameterivFn) {
-    debug_fn.glSamplerParameterivFn = fn.glSamplerParameterivFn;
-    fn.glSamplerParameterivFn = Debug_glSamplerParameteriv;
-  }
-  if (!debug_fn.glSamplerParameterivRobustANGLEFn) {
-    debug_fn.glSamplerParameterivRobustANGLEFn =
-        fn.glSamplerParameterivRobustANGLEFn;
-    fn.glSamplerParameterivRobustANGLEFn =
-        Debug_glSamplerParameterivRobustANGLE;
-  }
-  if (!debug_fn.glScissorFn) {
-    debug_fn.glScissorFn = fn.glScissorFn;
-    fn.glScissorFn = Debug_glScissor;
-  }
-  if (!debug_fn.glSetFenceAPPLEFn) {
-    debug_fn.glSetFenceAPPLEFn = fn.glSetFenceAPPLEFn;
-    fn.glSetFenceAPPLEFn = Debug_glSetFenceAPPLE;
-  }
-  if (!debug_fn.glSetFenceNVFn) {
-    debug_fn.glSetFenceNVFn = fn.glSetFenceNVFn;
-    fn.glSetFenceNVFn = Debug_glSetFenceNV;
-  }
-  if (!debug_fn.glShaderBinaryFn) {
-    debug_fn.glShaderBinaryFn = fn.glShaderBinaryFn;
-    fn.glShaderBinaryFn = Debug_glShaderBinary;
-  }
-  if (!debug_fn.glShaderSourceFn) {
-    debug_fn.glShaderSourceFn = fn.glShaderSourceFn;
-    fn.glShaderSourceFn = Debug_glShaderSource;
-  }
-  if (!debug_fn.glStencilFillPathInstancedNVFn) {
-    debug_fn.glStencilFillPathInstancedNVFn = fn.glStencilFillPathInstancedNVFn;
-    fn.glStencilFillPathInstancedNVFn = Debug_glStencilFillPathInstancedNV;
-  }
-  if (!debug_fn.glStencilFillPathNVFn) {
-    debug_fn.glStencilFillPathNVFn = fn.glStencilFillPathNVFn;
-    fn.glStencilFillPathNVFn = Debug_glStencilFillPathNV;
-  }
-  if (!debug_fn.glStencilFuncFn) {
-    debug_fn.glStencilFuncFn = fn.glStencilFuncFn;
-    fn.glStencilFuncFn = Debug_glStencilFunc;
-  }
-  if (!debug_fn.glStencilFuncSeparateFn) {
-    debug_fn.glStencilFuncSeparateFn = fn.glStencilFuncSeparateFn;
-    fn.glStencilFuncSeparateFn = Debug_glStencilFuncSeparate;
-  }
-  if (!debug_fn.glStencilMaskFn) {
-    debug_fn.glStencilMaskFn = fn.glStencilMaskFn;
-    fn.glStencilMaskFn = Debug_glStencilMask;
-  }
-  if (!debug_fn.glStencilMaskSeparateFn) {
-    debug_fn.glStencilMaskSeparateFn = fn.glStencilMaskSeparateFn;
-    fn.glStencilMaskSeparateFn = Debug_glStencilMaskSeparate;
-  }
-  if (!debug_fn.glStencilOpFn) {
-    debug_fn.glStencilOpFn = fn.glStencilOpFn;
-    fn.glStencilOpFn = Debug_glStencilOp;
-  }
-  if (!debug_fn.glStencilOpSeparateFn) {
-    debug_fn.glStencilOpSeparateFn = fn.glStencilOpSeparateFn;
-    fn.glStencilOpSeparateFn = Debug_glStencilOpSeparate;
-  }
-  if (!debug_fn.glStencilStrokePathInstancedNVFn) {
-    debug_fn.glStencilStrokePathInstancedNVFn =
-        fn.glStencilStrokePathInstancedNVFn;
-    fn.glStencilStrokePathInstancedNVFn = Debug_glStencilStrokePathInstancedNV;
-  }
-  if (!debug_fn.glStencilStrokePathNVFn) {
-    debug_fn.glStencilStrokePathNVFn = fn.glStencilStrokePathNVFn;
-    fn.glStencilStrokePathNVFn = Debug_glStencilStrokePathNV;
-  }
-  if (!debug_fn.glStencilThenCoverFillPathInstancedNVFn) {
-    debug_fn.glStencilThenCoverFillPathInstancedNVFn =
-        fn.glStencilThenCoverFillPathInstancedNVFn;
-    fn.glStencilThenCoverFillPathInstancedNVFn =
-        Debug_glStencilThenCoverFillPathInstancedNV;
-  }
-  if (!debug_fn.glStencilThenCoverFillPathNVFn) {
-    debug_fn.glStencilThenCoverFillPathNVFn = fn.glStencilThenCoverFillPathNVFn;
-    fn.glStencilThenCoverFillPathNVFn = Debug_glStencilThenCoverFillPathNV;
-  }
-  if (!debug_fn.glStencilThenCoverStrokePathInstancedNVFn) {
-    debug_fn.glStencilThenCoverStrokePathInstancedNVFn =
-        fn.glStencilThenCoverStrokePathInstancedNVFn;
-    fn.glStencilThenCoverStrokePathInstancedNVFn =
-        Debug_glStencilThenCoverStrokePathInstancedNV;
-  }
-  if (!debug_fn.glStencilThenCoverStrokePathNVFn) {
-    debug_fn.glStencilThenCoverStrokePathNVFn =
-        fn.glStencilThenCoverStrokePathNVFn;
-    fn.glStencilThenCoverStrokePathNVFn = Debug_glStencilThenCoverStrokePathNV;
-  }
-  if (!debug_fn.glTestFenceAPPLEFn) {
-    debug_fn.glTestFenceAPPLEFn = fn.glTestFenceAPPLEFn;
-    fn.glTestFenceAPPLEFn = Debug_glTestFenceAPPLE;
-  }
-  if (!debug_fn.glTestFenceNVFn) {
-    debug_fn.glTestFenceNVFn = fn.glTestFenceNVFn;
-    fn.glTestFenceNVFn = Debug_glTestFenceNV;
-  }
-  if (!debug_fn.glTexImage2DFn) {
-    debug_fn.glTexImage2DFn = fn.glTexImage2DFn;
-    fn.glTexImage2DFn = Debug_glTexImage2D;
-  }
-  if (!debug_fn.glTexImage2DRobustANGLEFn) {
-    debug_fn.glTexImage2DRobustANGLEFn = fn.glTexImage2DRobustANGLEFn;
-    fn.glTexImage2DRobustANGLEFn = Debug_glTexImage2DRobustANGLE;
-  }
-  if (!debug_fn.glTexImage3DFn) {
-    debug_fn.glTexImage3DFn = fn.glTexImage3DFn;
-    fn.glTexImage3DFn = Debug_glTexImage3D;
-  }
-  if (!debug_fn.glTexImage3DRobustANGLEFn) {
-    debug_fn.glTexImage3DRobustANGLEFn = fn.glTexImage3DRobustANGLEFn;
-    fn.glTexImage3DRobustANGLEFn = Debug_glTexImage3DRobustANGLE;
-  }
-  if (!debug_fn.glTexParameterfFn) {
-    debug_fn.glTexParameterfFn = fn.glTexParameterfFn;
-    fn.glTexParameterfFn = Debug_glTexParameterf;
-  }
-  if (!debug_fn.glTexParameterfvFn) {
-    debug_fn.glTexParameterfvFn = fn.glTexParameterfvFn;
-    fn.glTexParameterfvFn = Debug_glTexParameterfv;
-  }
-  if (!debug_fn.glTexParameterfvRobustANGLEFn) {
-    debug_fn.glTexParameterfvRobustANGLEFn = fn.glTexParameterfvRobustANGLEFn;
-    fn.glTexParameterfvRobustANGLEFn = Debug_glTexParameterfvRobustANGLE;
-  }
-  if (!debug_fn.glTexParameteriFn) {
-    debug_fn.glTexParameteriFn = fn.glTexParameteriFn;
-    fn.glTexParameteriFn = Debug_glTexParameteri;
-  }
-  if (!debug_fn.glTexParameterIivRobustANGLEFn) {
-    debug_fn.glTexParameterIivRobustANGLEFn = fn.glTexParameterIivRobustANGLEFn;
-    fn.glTexParameterIivRobustANGLEFn = Debug_glTexParameterIivRobustANGLE;
-  }
-  if (!debug_fn.glTexParameterIuivRobustANGLEFn) {
-    debug_fn.glTexParameterIuivRobustANGLEFn =
-        fn.glTexParameterIuivRobustANGLEFn;
-    fn.glTexParameterIuivRobustANGLEFn = Debug_glTexParameterIuivRobustANGLE;
-  }
-  if (!debug_fn.glTexParameterivFn) {
-    debug_fn.glTexParameterivFn = fn.glTexParameterivFn;
-    fn.glTexParameterivFn = Debug_glTexParameteriv;
-  }
-  if (!debug_fn.glTexParameterivRobustANGLEFn) {
-    debug_fn.glTexParameterivRobustANGLEFn = fn.glTexParameterivRobustANGLEFn;
-    fn.glTexParameterivRobustANGLEFn = Debug_glTexParameterivRobustANGLE;
-  }
-  if (!debug_fn.glTexStorage2DEXTFn) {
-    debug_fn.glTexStorage2DEXTFn = fn.glTexStorage2DEXTFn;
-    fn.glTexStorage2DEXTFn = Debug_glTexStorage2DEXT;
-  }
-  if (!debug_fn.glTexStorage3DFn) {
-    debug_fn.glTexStorage3DFn = fn.glTexStorage3DFn;
-    fn.glTexStorage3DFn = Debug_glTexStorage3D;
-  }
-  if (!debug_fn.glTexSubImage2DFn) {
-    debug_fn.glTexSubImage2DFn = fn.glTexSubImage2DFn;
-    fn.glTexSubImage2DFn = Debug_glTexSubImage2D;
-  }
-  if (!debug_fn.glTexSubImage2DRobustANGLEFn) {
-    debug_fn.glTexSubImage2DRobustANGLEFn = fn.glTexSubImage2DRobustANGLEFn;
-    fn.glTexSubImage2DRobustANGLEFn = Debug_glTexSubImage2DRobustANGLE;
-  }
-  if (!debug_fn.glTexSubImage3DFn) {
-    debug_fn.glTexSubImage3DFn = fn.glTexSubImage3DFn;
-    fn.glTexSubImage3DFn = Debug_glTexSubImage3D;
-  }
-  if (!debug_fn.glTexSubImage3DRobustANGLEFn) {
-    debug_fn.glTexSubImage3DRobustANGLEFn = fn.glTexSubImage3DRobustANGLEFn;
-    fn.glTexSubImage3DRobustANGLEFn = Debug_glTexSubImage3DRobustANGLE;
-  }
-  if (!debug_fn.glTransformFeedbackVaryingsFn) {
-    debug_fn.glTransformFeedbackVaryingsFn = fn.glTransformFeedbackVaryingsFn;
-    fn.glTransformFeedbackVaryingsFn = Debug_glTransformFeedbackVaryings;
-  }
-  if (!debug_fn.glUniform1fFn) {
-    debug_fn.glUniform1fFn = fn.glUniform1fFn;
-    fn.glUniform1fFn = Debug_glUniform1f;
-  }
-  if (!debug_fn.glUniform1fvFn) {
-    debug_fn.glUniform1fvFn = fn.glUniform1fvFn;
-    fn.glUniform1fvFn = Debug_glUniform1fv;
-  }
-  if (!debug_fn.glUniform1iFn) {
-    debug_fn.glUniform1iFn = fn.glUniform1iFn;
-    fn.glUniform1iFn = Debug_glUniform1i;
-  }
-  if (!debug_fn.glUniform1ivFn) {
-    debug_fn.glUniform1ivFn = fn.glUniform1ivFn;
-    fn.glUniform1ivFn = Debug_glUniform1iv;
-  }
-  if (!debug_fn.glUniform1uiFn) {
-    debug_fn.glUniform1uiFn = fn.glUniform1uiFn;
-    fn.glUniform1uiFn = Debug_glUniform1ui;
-  }
-  if (!debug_fn.glUniform1uivFn) {
-    debug_fn.glUniform1uivFn = fn.glUniform1uivFn;
-    fn.glUniform1uivFn = Debug_glUniform1uiv;
-  }
-  if (!debug_fn.glUniform2fFn) {
-    debug_fn.glUniform2fFn = fn.glUniform2fFn;
-    fn.glUniform2fFn = Debug_glUniform2f;
-  }
-  if (!debug_fn.glUniform2fvFn) {
-    debug_fn.glUniform2fvFn = fn.glUniform2fvFn;
-    fn.glUniform2fvFn = Debug_glUniform2fv;
-  }
-  if (!debug_fn.glUniform2iFn) {
-    debug_fn.glUniform2iFn = fn.glUniform2iFn;
-    fn.glUniform2iFn = Debug_glUniform2i;
-  }
-  if (!debug_fn.glUniform2ivFn) {
-    debug_fn.glUniform2ivFn = fn.glUniform2ivFn;
-    fn.glUniform2ivFn = Debug_glUniform2iv;
-  }
-  if (!debug_fn.glUniform2uiFn) {
-    debug_fn.glUniform2uiFn = fn.glUniform2uiFn;
-    fn.glUniform2uiFn = Debug_glUniform2ui;
-  }
-  if (!debug_fn.glUniform2uivFn) {
-    debug_fn.glUniform2uivFn = fn.glUniform2uivFn;
-    fn.glUniform2uivFn = Debug_glUniform2uiv;
-  }
-  if (!debug_fn.glUniform3fFn) {
-    debug_fn.glUniform3fFn = fn.glUniform3fFn;
-    fn.glUniform3fFn = Debug_glUniform3f;
-  }
-  if (!debug_fn.glUniform3fvFn) {
-    debug_fn.glUniform3fvFn = fn.glUniform3fvFn;
-    fn.glUniform3fvFn = Debug_glUniform3fv;
-  }
-  if (!debug_fn.glUniform3iFn) {
-    debug_fn.glUniform3iFn = fn.glUniform3iFn;
-    fn.glUniform3iFn = Debug_glUniform3i;
-  }
-  if (!debug_fn.glUniform3ivFn) {
-    debug_fn.glUniform3ivFn = fn.glUniform3ivFn;
-    fn.glUniform3ivFn = Debug_glUniform3iv;
-  }
-  if (!debug_fn.glUniform3uiFn) {
-    debug_fn.glUniform3uiFn = fn.glUniform3uiFn;
-    fn.glUniform3uiFn = Debug_glUniform3ui;
-  }
-  if (!debug_fn.glUniform3uivFn) {
-    debug_fn.glUniform3uivFn = fn.glUniform3uivFn;
-    fn.glUniform3uivFn = Debug_glUniform3uiv;
-  }
-  if (!debug_fn.glUniform4fFn) {
-    debug_fn.glUniform4fFn = fn.glUniform4fFn;
-    fn.glUniform4fFn = Debug_glUniform4f;
-  }
-  if (!debug_fn.glUniform4fvFn) {
-    debug_fn.glUniform4fvFn = fn.glUniform4fvFn;
-    fn.glUniform4fvFn = Debug_glUniform4fv;
-  }
-  if (!debug_fn.glUniform4iFn) {
-    debug_fn.glUniform4iFn = fn.glUniform4iFn;
-    fn.glUniform4iFn = Debug_glUniform4i;
-  }
-  if (!debug_fn.glUniform4ivFn) {
-    debug_fn.glUniform4ivFn = fn.glUniform4ivFn;
-    fn.glUniform4ivFn = Debug_glUniform4iv;
-  }
-  if (!debug_fn.glUniform4uiFn) {
-    debug_fn.glUniform4uiFn = fn.glUniform4uiFn;
-    fn.glUniform4uiFn = Debug_glUniform4ui;
-  }
-  if (!debug_fn.glUniform4uivFn) {
-    debug_fn.glUniform4uivFn = fn.glUniform4uivFn;
-    fn.glUniform4uivFn = Debug_glUniform4uiv;
-  }
-  if (!debug_fn.glUniformBlockBindingFn) {
-    debug_fn.glUniformBlockBindingFn = fn.glUniformBlockBindingFn;
-    fn.glUniformBlockBindingFn = Debug_glUniformBlockBinding;
-  }
-  if (!debug_fn.glUniformMatrix2fvFn) {
-    debug_fn.glUniformMatrix2fvFn = fn.glUniformMatrix2fvFn;
-    fn.glUniformMatrix2fvFn = Debug_glUniformMatrix2fv;
-  }
-  if (!debug_fn.glUniformMatrix2x3fvFn) {
-    debug_fn.glUniformMatrix2x3fvFn = fn.glUniformMatrix2x3fvFn;
-    fn.glUniformMatrix2x3fvFn = Debug_glUniformMatrix2x3fv;
-  }
-  if (!debug_fn.glUniformMatrix2x4fvFn) {
-    debug_fn.glUniformMatrix2x4fvFn = fn.glUniformMatrix2x4fvFn;
-    fn.glUniformMatrix2x4fvFn = Debug_glUniformMatrix2x4fv;
-  }
-  if (!debug_fn.glUniformMatrix3fvFn) {
-    debug_fn.glUniformMatrix3fvFn = fn.glUniformMatrix3fvFn;
-    fn.glUniformMatrix3fvFn = Debug_glUniformMatrix3fv;
-  }
-  if (!debug_fn.glUniformMatrix3x2fvFn) {
-    debug_fn.glUniformMatrix3x2fvFn = fn.glUniformMatrix3x2fvFn;
-    fn.glUniformMatrix3x2fvFn = Debug_glUniformMatrix3x2fv;
-  }
-  if (!debug_fn.glUniformMatrix3x4fvFn) {
-    debug_fn.glUniformMatrix3x4fvFn = fn.glUniformMatrix3x4fvFn;
-    fn.glUniformMatrix3x4fvFn = Debug_glUniformMatrix3x4fv;
-  }
-  if (!debug_fn.glUniformMatrix4fvFn) {
-    debug_fn.glUniformMatrix4fvFn = fn.glUniformMatrix4fvFn;
-    fn.glUniformMatrix4fvFn = Debug_glUniformMatrix4fv;
-  }
-  if (!debug_fn.glUniformMatrix4x2fvFn) {
-    debug_fn.glUniformMatrix4x2fvFn = fn.glUniformMatrix4x2fvFn;
-    fn.glUniformMatrix4x2fvFn = Debug_glUniformMatrix4x2fv;
-  }
-  if (!debug_fn.glUniformMatrix4x3fvFn) {
-    debug_fn.glUniformMatrix4x3fvFn = fn.glUniformMatrix4x3fvFn;
-    fn.glUniformMatrix4x3fvFn = Debug_glUniformMatrix4x3fv;
-  }
-  if (!debug_fn.glUnmapBufferFn) {
-    debug_fn.glUnmapBufferFn = fn.glUnmapBufferFn;
-    fn.glUnmapBufferFn = Debug_glUnmapBuffer;
-  }
-  if (!debug_fn.glUseProgramFn) {
-    debug_fn.glUseProgramFn = fn.glUseProgramFn;
-    fn.glUseProgramFn = Debug_glUseProgram;
-  }
-  if (!debug_fn.glValidateProgramFn) {
-    debug_fn.glValidateProgramFn = fn.glValidateProgramFn;
-    fn.glValidateProgramFn = Debug_glValidateProgram;
-  }
-  if (!debug_fn.glVertexAttrib1fFn) {
-    debug_fn.glVertexAttrib1fFn = fn.glVertexAttrib1fFn;
-    fn.glVertexAttrib1fFn = Debug_glVertexAttrib1f;
-  }
-  if (!debug_fn.glVertexAttrib1fvFn) {
-    debug_fn.glVertexAttrib1fvFn = fn.glVertexAttrib1fvFn;
-    fn.glVertexAttrib1fvFn = Debug_glVertexAttrib1fv;
-  }
-  if (!debug_fn.glVertexAttrib2fFn) {
-    debug_fn.glVertexAttrib2fFn = fn.glVertexAttrib2fFn;
-    fn.glVertexAttrib2fFn = Debug_glVertexAttrib2f;
-  }
-  if (!debug_fn.glVertexAttrib2fvFn) {
-    debug_fn.glVertexAttrib2fvFn = fn.glVertexAttrib2fvFn;
-    fn.glVertexAttrib2fvFn = Debug_glVertexAttrib2fv;
-  }
-  if (!debug_fn.glVertexAttrib3fFn) {
-    debug_fn.glVertexAttrib3fFn = fn.glVertexAttrib3fFn;
-    fn.glVertexAttrib3fFn = Debug_glVertexAttrib3f;
-  }
-  if (!debug_fn.glVertexAttrib3fvFn) {
-    debug_fn.glVertexAttrib3fvFn = fn.glVertexAttrib3fvFn;
-    fn.glVertexAttrib3fvFn = Debug_glVertexAttrib3fv;
-  }
-  if (!debug_fn.glVertexAttrib4fFn) {
-    debug_fn.glVertexAttrib4fFn = fn.glVertexAttrib4fFn;
-    fn.glVertexAttrib4fFn = Debug_glVertexAttrib4f;
-  }
-  if (!debug_fn.glVertexAttrib4fvFn) {
-    debug_fn.glVertexAttrib4fvFn = fn.glVertexAttrib4fvFn;
-    fn.glVertexAttrib4fvFn = Debug_glVertexAttrib4fv;
-  }
-  if (!debug_fn.glVertexAttribDivisorANGLEFn) {
-    debug_fn.glVertexAttribDivisorANGLEFn = fn.glVertexAttribDivisorANGLEFn;
-    fn.glVertexAttribDivisorANGLEFn = Debug_glVertexAttribDivisorANGLE;
-  }
-  if (!debug_fn.glVertexAttribI4iFn) {
-    debug_fn.glVertexAttribI4iFn = fn.glVertexAttribI4iFn;
-    fn.glVertexAttribI4iFn = Debug_glVertexAttribI4i;
-  }
-  if (!debug_fn.glVertexAttribI4ivFn) {
-    debug_fn.glVertexAttribI4ivFn = fn.glVertexAttribI4ivFn;
-    fn.glVertexAttribI4ivFn = Debug_glVertexAttribI4iv;
-  }
-  if (!debug_fn.glVertexAttribI4uiFn) {
-    debug_fn.glVertexAttribI4uiFn = fn.glVertexAttribI4uiFn;
-    fn.glVertexAttribI4uiFn = Debug_glVertexAttribI4ui;
-  }
-  if (!debug_fn.glVertexAttribI4uivFn) {
-    debug_fn.glVertexAttribI4uivFn = fn.glVertexAttribI4uivFn;
-    fn.glVertexAttribI4uivFn = Debug_glVertexAttribI4uiv;
-  }
-  if (!debug_fn.glVertexAttribIPointerFn) {
-    debug_fn.glVertexAttribIPointerFn = fn.glVertexAttribIPointerFn;
-    fn.glVertexAttribIPointerFn = Debug_glVertexAttribIPointer;
-  }
-  if (!debug_fn.glVertexAttribPointerFn) {
-    debug_fn.glVertexAttribPointerFn = fn.glVertexAttribPointerFn;
-    fn.glVertexAttribPointerFn = Debug_glVertexAttribPointer;
-  }
-  if (!debug_fn.glViewportFn) {
-    debug_fn.glViewportFn = fn.glViewportFn;
-    fn.glViewportFn = Debug_glViewport;
-  }
-  if (!debug_fn.glWaitSyncFn) {
-    debug_fn.glWaitSyncFn = fn.glWaitSyncFn;
-    fn.glWaitSyncFn = Debug_glWaitSync;
-  }
-  g_debugBindingsInitialized = true;
 }
 
 void DriverGL::ClearBindings() {
@@ -14578,6 +8031,4003 @@ GLenum TraceGLApi::glWaitSyncFn(GLsync sync,
   return gl_api_->glWaitSyncFn(sync, flags, timeout);
 }
 
+void DebugGLApi::glActiveTextureFn(GLenum texture) {
+  GL_SERVICE_LOG("glActiveTexture"
+                 << "(" << GLEnums::GetStringEnum(texture) << ")");
+  gl_api_->glActiveTextureFn(texture);
+}
+
+void DebugGLApi::glApplyFramebufferAttachmentCMAAINTELFn(void) {
+  GL_SERVICE_LOG("glApplyFramebufferAttachmentCMAAINTEL"
+                 << "("
+                 << ")");
+  gl_api_->glApplyFramebufferAttachmentCMAAINTELFn();
+}
+
+void DebugGLApi::glAttachShaderFn(GLuint program, GLuint shader) {
+  GL_SERVICE_LOG("glAttachShader"
+                 << "(" << program << ", " << shader << ")");
+  gl_api_->glAttachShaderFn(program, shader);
+}
+
+void DebugGLApi::glBeginQueryFn(GLenum target, GLuint id) {
+  GL_SERVICE_LOG("glBeginQuery"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
+  gl_api_->glBeginQueryFn(target, id);
+}
+
+void DebugGLApi::glBeginTransformFeedbackFn(GLenum primitiveMode) {
+  GL_SERVICE_LOG("glBeginTransformFeedback"
+                 << "(" << GLEnums::GetStringEnum(primitiveMode) << ")");
+  gl_api_->glBeginTransformFeedbackFn(primitiveMode);
+}
+
+void DebugGLApi::glBindAttribLocationFn(GLuint program,
+                                        GLuint index,
+                                        const char* name) {
+  GL_SERVICE_LOG("glBindAttribLocation"
+                 << "(" << program << ", " << index << ", " << name << ")");
+  gl_api_->glBindAttribLocationFn(program, index, name);
+}
+
+void DebugGLApi::glBindBufferFn(GLenum target, GLuint buffer) {
+  GL_SERVICE_LOG("glBindBuffer"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << buffer
+                 << ")");
+  gl_api_->glBindBufferFn(target, buffer);
+}
+
+void DebugGLApi::glBindBufferBaseFn(GLenum target,
+                                    GLuint index,
+                                    GLuint buffer) {
+  GL_SERVICE_LOG("glBindBufferBase"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
+                 << ", " << buffer << ")");
+  gl_api_->glBindBufferBaseFn(target, index, buffer);
+}
+
+void DebugGLApi::glBindBufferRangeFn(GLenum target,
+                                     GLuint index,
+                                     GLuint buffer,
+                                     GLintptr offset,
+                                     GLsizeiptr size) {
+  GL_SERVICE_LOG("glBindBufferRange"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
+                 << ", " << buffer << ", " << offset << ", " << size << ")");
+  gl_api_->glBindBufferRangeFn(target, index, buffer, offset, size);
+}
+
+void DebugGLApi::glBindFragDataLocationFn(GLuint program,
+                                          GLuint colorNumber,
+                                          const char* name) {
+  GL_SERVICE_LOG("glBindFragDataLocation"
+                 << "(" << program << ", " << colorNumber << ", " << name
+                 << ")");
+  gl_api_->glBindFragDataLocationFn(program, colorNumber, name);
+}
+
+void DebugGLApi::glBindFragDataLocationIndexedFn(GLuint program,
+                                                 GLuint colorNumber,
+                                                 GLuint index,
+                                                 const char* name) {
+  GL_SERVICE_LOG("glBindFragDataLocationIndexed"
+                 << "(" << program << ", " << colorNumber << ", " << index
+                 << ", " << name << ")");
+  gl_api_->glBindFragDataLocationIndexedFn(program, colorNumber, index, name);
+}
+
+void DebugGLApi::glBindFramebufferEXTFn(GLenum target, GLuint framebuffer) {
+  GL_SERVICE_LOG("glBindFramebufferEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << framebuffer
+                 << ")");
+  gl_api_->glBindFramebufferEXTFn(target, framebuffer);
+}
+
+void DebugGLApi::glBindImageTextureEXTFn(GLuint index,
+                                         GLuint texture,
+                                         GLint level,
+                                         GLboolean layered,
+                                         GLint layer,
+                                         GLenum access,
+                                         GLint format) {
+  GL_SERVICE_LOG("glBindImageTextureEXT"
+                 << "(" << index << ", " << texture << ", " << level << ", "
+                 << GLEnums::GetStringBool(layered) << ", " << layer << ", "
+                 << GLEnums::GetStringEnum(access) << ", " << format << ")");
+  gl_api_->glBindImageTextureEXTFn(index, texture, level, layered, layer,
+                                   access, format);
+}
+
+void DebugGLApi::glBindRenderbufferEXTFn(GLenum target, GLuint renderbuffer) {
+  GL_SERVICE_LOG("glBindRenderbufferEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << renderbuffer << ")");
+  gl_api_->glBindRenderbufferEXTFn(target, renderbuffer);
+}
+
+void DebugGLApi::glBindSamplerFn(GLuint unit, GLuint sampler) {
+  GL_SERVICE_LOG("glBindSampler"
+                 << "(" << unit << ", " << sampler << ")");
+  gl_api_->glBindSamplerFn(unit, sampler);
+}
+
+void DebugGLApi::glBindTextureFn(GLenum target, GLuint texture) {
+  GL_SERVICE_LOG("glBindTexture"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << texture
+                 << ")");
+  gl_api_->glBindTextureFn(target, texture);
+}
+
+void DebugGLApi::glBindTransformFeedbackFn(GLenum target, GLuint id) {
+  GL_SERVICE_LOG("glBindTransformFeedback"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
+  gl_api_->glBindTransformFeedbackFn(target, id);
+}
+
+void DebugGLApi::glBindUniformLocationCHROMIUMFn(GLuint program,
+                                                 GLint location,
+                                                 const char* name) {
+  GL_SERVICE_LOG("glBindUniformLocationCHROMIUM"
+                 << "(" << program << ", " << location << ", " << name << ")");
+  gl_api_->glBindUniformLocationCHROMIUMFn(program, location, name);
+}
+
+void DebugGLApi::glBindVertexArrayOESFn(GLuint array) {
+  GL_SERVICE_LOG("glBindVertexArrayOES"
+                 << "(" << array << ")");
+  gl_api_->glBindVertexArrayOESFn(array);
+}
+
+void DebugGLApi::glBlendBarrierKHRFn(void) {
+  GL_SERVICE_LOG("glBlendBarrierKHR"
+                 << "("
+                 << ")");
+  gl_api_->glBlendBarrierKHRFn();
+}
+
+void DebugGLApi::glBlendColorFn(GLclampf red,
+                                GLclampf green,
+                                GLclampf blue,
+                                GLclampf alpha) {
+  GL_SERVICE_LOG("glBlendColor"
+                 << "(" << red << ", " << green << ", " << blue << ", " << alpha
+                 << ")");
+  gl_api_->glBlendColorFn(red, green, blue, alpha);
+}
+
+void DebugGLApi::glBlendEquationFn(GLenum mode) {
+  GL_SERVICE_LOG("glBlendEquation"
+                 << "(" << GLEnums::GetStringEnum(mode) << ")");
+  gl_api_->glBlendEquationFn(mode);
+}
+
+void DebugGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) {
+  GL_SERVICE_LOG("glBlendEquationSeparate"
+                 << "(" << GLEnums::GetStringEnum(modeRGB) << ", "
+                 << GLEnums::GetStringEnum(modeAlpha) << ")");
+  gl_api_->glBlendEquationSeparateFn(modeRGB, modeAlpha);
+}
+
+void DebugGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) {
+  GL_SERVICE_LOG("glBlendFunc"
+                 << "(" << GLEnums::GetStringEnum(sfactor) << ", "
+                 << GLEnums::GetStringEnum(dfactor) << ")");
+  gl_api_->glBlendFuncFn(sfactor, dfactor);
+}
+
+void DebugGLApi::glBlendFuncSeparateFn(GLenum srcRGB,
+                                       GLenum dstRGB,
+                                       GLenum srcAlpha,
+                                       GLenum dstAlpha) {
+  GL_SERVICE_LOG("glBlendFuncSeparate"
+                 << "(" << GLEnums::GetStringEnum(srcRGB) << ", "
+                 << GLEnums::GetStringEnum(dstRGB) << ", "
+                 << GLEnums::GetStringEnum(srcAlpha) << ", "
+                 << GLEnums::GetStringEnum(dstAlpha) << ")");
+  gl_api_->glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void DebugGLApi::glBlitFramebufferFn(GLint srcX0,
+                                     GLint srcY0,
+                                     GLint srcX1,
+                                     GLint srcY1,
+                                     GLint dstX0,
+                                     GLint dstY0,
+                                     GLint dstX1,
+                                     GLint dstY1,
+                                     GLbitfield mask,
+                                     GLenum filter) {
+  GL_SERVICE_LOG("glBlitFramebuffer"
+                 << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
+                 << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
+                 << ", " << dstY1 << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(filter) << ")");
+  gl_api_->glBlitFramebufferFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
+                               dstY1, mask, filter);
+}
+
+void DebugGLApi::glBlitFramebufferANGLEFn(GLint srcX0,
+                                          GLint srcY0,
+                                          GLint srcX1,
+                                          GLint srcY1,
+                                          GLint dstX0,
+                                          GLint dstY0,
+                                          GLint dstX1,
+                                          GLint dstY1,
+                                          GLbitfield mask,
+                                          GLenum filter) {
+  GL_SERVICE_LOG("glBlitFramebufferANGLE"
+                 << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
+                 << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
+                 << ", " << dstY1 << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(filter) << ")");
+  gl_api_->glBlitFramebufferANGLEFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+                                    dstX1, dstY1, mask, filter);
+}
+
+void DebugGLApi::glBlitFramebufferEXTFn(GLint srcX0,
+                                        GLint srcY0,
+                                        GLint srcX1,
+                                        GLint srcY1,
+                                        GLint dstX0,
+                                        GLint dstY0,
+                                        GLint dstX1,
+                                        GLint dstY1,
+                                        GLbitfield mask,
+                                        GLenum filter) {
+  GL_SERVICE_LOG("glBlitFramebufferEXT"
+                 << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
+                 << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
+                 << ", " << dstY1 << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(filter) << ")");
+  gl_api_->glBlitFramebufferEXTFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+                                  dstX1, dstY1, mask, filter);
+}
+
+void DebugGLApi::glBufferDataFn(GLenum target,
+                                GLsizeiptr size,
+                                const void* data,
+                                GLenum usage) {
+  GL_SERVICE_LOG("glBufferData"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << size
+                 << ", " << static_cast<const void*>(data) << ", "
+                 << GLEnums::GetStringEnum(usage) << ")");
+  gl_api_->glBufferDataFn(target, size, data, usage);
+}
+
+void DebugGLApi::glBufferSubDataFn(GLenum target,
+                                   GLintptr offset,
+                                   GLsizeiptr size,
+                                   const void* data) {
+  GL_SERVICE_LOG("glBufferSubData"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << offset
+                 << ", " << size << ", " << static_cast<const void*>(data)
+                 << ")");
+  gl_api_->glBufferSubDataFn(target, offset, size, data);
+}
+
+GLenum DebugGLApi::glCheckFramebufferStatusEXTFn(GLenum target) {
+  GL_SERVICE_LOG("glCheckFramebufferStatusEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ")");
+  GLenum result = gl_api_->glCheckFramebufferStatusEXTFn(target);
+
+  GL_SERVICE_LOG("GL_RESULT: " << GLEnums::GetStringEnum(result));
+
+  return result;
+}
+
+void DebugGLApi::glClearFn(GLbitfield mask) {
+  GL_SERVICE_LOG("glClear"
+                 << "(" << mask << ")");
+  gl_api_->glClearFn(mask);
+}
+
+void DebugGLApi::glClearBufferfiFn(GLenum buffer,
+                                   GLint drawbuffer,
+                                   const GLfloat depth,
+                                   GLint stencil) {
+  GL_SERVICE_LOG("glClearBufferfi"
+                 << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
+                 << ", " << depth << ", " << stencil << ")");
+  gl_api_->glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
+}
+
+void DebugGLApi::glClearBufferfvFn(GLenum buffer,
+                                   GLint drawbuffer,
+                                   const GLfloat* value) {
+  GL_SERVICE_LOG("glClearBufferfv"
+                 << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
+                 << ", " << static_cast<const void*>(value) << ")");
+  gl_api_->glClearBufferfvFn(buffer, drawbuffer, value);
+}
+
+void DebugGLApi::glClearBufferivFn(GLenum buffer,
+                                   GLint drawbuffer,
+                                   const GLint* value) {
+  GL_SERVICE_LOG("glClearBufferiv"
+                 << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
+                 << ", " << static_cast<const void*>(value) << ")");
+  gl_api_->glClearBufferivFn(buffer, drawbuffer, value);
+}
+
+void DebugGLApi::glClearBufferuivFn(GLenum buffer,
+                                    GLint drawbuffer,
+                                    const GLuint* value) {
+  GL_SERVICE_LOG("glClearBufferuiv"
+                 << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
+                 << ", " << static_cast<const void*>(value) << ")");
+  gl_api_->glClearBufferuivFn(buffer, drawbuffer, value);
+}
+
+void DebugGLApi::glClearColorFn(GLclampf red,
+                                GLclampf green,
+                                GLclampf blue,
+                                GLclampf alpha) {
+  GL_SERVICE_LOG("glClearColor"
+                 << "(" << red << ", " << green << ", " << blue << ", " << alpha
+                 << ")");
+  gl_api_->glClearColorFn(red, green, blue, alpha);
+}
+
+void DebugGLApi::glClearDepthFn(GLclampd depth) {
+  GL_SERVICE_LOG("glClearDepth"
+                 << "(" << depth << ")");
+  gl_api_->glClearDepthFn(depth);
+}
+
+void DebugGLApi::glClearDepthfFn(GLclampf depth) {
+  GL_SERVICE_LOG("glClearDepthf"
+                 << "(" << depth << ")");
+  gl_api_->glClearDepthfFn(depth);
+}
+
+void DebugGLApi::glClearStencilFn(GLint s) {
+  GL_SERVICE_LOG("glClearStencil"
+                 << "(" << s << ")");
+  gl_api_->glClearStencilFn(s);
+}
+
+GLenum DebugGLApi::glClientWaitSyncFn(GLsync sync,
+                                      GLbitfield flags,
+                                      GLuint64 timeout) {
+  GL_SERVICE_LOG("glClientWaitSync"
+                 << "(" << sync << ", " << flags << ", " << timeout << ")");
+  GLenum result = gl_api_->glClientWaitSyncFn(sync, flags, timeout);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glColorMaskFn(GLboolean red,
+                               GLboolean green,
+                               GLboolean blue,
+                               GLboolean alpha) {
+  GL_SERVICE_LOG("glColorMask"
+                 << "(" << GLEnums::GetStringBool(red) << ", "
+                 << GLEnums::GetStringBool(green) << ", "
+                 << GLEnums::GetStringBool(blue) << ", "
+                 << GLEnums::GetStringBool(alpha) << ")");
+  gl_api_->glColorMaskFn(red, green, blue, alpha);
+}
+
+void DebugGLApi::glCompileShaderFn(GLuint shader) {
+  GL_SERVICE_LOG("glCompileShader"
+                 << "(" << shader << ")");
+  gl_api_->glCompileShaderFn(shader);
+}
+
+void DebugGLApi::glCompressedCopyTextureCHROMIUMFn(GLuint sourceId,
+                                                   GLuint destId) {
+  GL_SERVICE_LOG("glCompressedCopyTextureCHROMIUM"
+                 << "(" << sourceId << ", " << destId << ")");
+  gl_api_->glCompressedCopyTextureCHROMIUMFn(sourceId, destId);
+}
+
+void DebugGLApi::glCompressedTexImage2DFn(GLenum target,
+                                          GLint level,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLint border,
+                                          GLsizei imageSize,
+                                          const void* data) {
+  GL_SERVICE_LOG("glCompressedTexImage2D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
+                 << width << ", " << height << ", " << border << ", "
+                 << imageSize << ", " << static_cast<const void*>(data) << ")");
+  gl_api_->glCompressedTexImage2DFn(target, level, internalformat, width,
+                                    height, border, imageSize, data);
+}
+
+void DebugGLApi::glCompressedTexImage3DFn(GLenum target,
+                                          GLint level,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLsizei depth,
+                                          GLint border,
+                                          GLsizei imageSize,
+                                          const void* data) {
+  GL_SERVICE_LOG("glCompressedTexImage3D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
+                 << width << ", " << height << ", " << depth << ", " << border
+                 << ", " << imageSize << ", " << static_cast<const void*>(data)
+                 << ")");
+  gl_api_->glCompressedTexImage3DFn(target, level, internalformat, width,
+                                    height, depth, border, imageSize, data);
+}
+
+void DebugGLApi::glCompressedTexSubImage2DFn(GLenum target,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLint yoffset,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLenum format,
+                                             GLsizei imageSize,
+                                             const void* data) {
+  GL_SERVICE_LOG("glCompressedTexSubImage2D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << xoffset << ", " << yoffset << ", " << width << ", "
+                 << height << ", " << GLEnums::GetStringEnum(format) << ", "
+                 << imageSize << ", " << static_cast<const void*>(data) << ")");
+  gl_api_->glCompressedTexSubImage2DFn(target, level, xoffset, yoffset, width,
+                                       height, format, imageSize, data);
+}
+
+void DebugGLApi::glCompressedTexSubImage3DFn(GLenum target,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLint yoffset,
+                                             GLint zoffset,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLsizei depth,
+                                             GLenum format,
+                                             GLsizei imageSize,
+                                             const void* data) {
+  GL_SERVICE_LOG("glCompressedTexSubImage3D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << xoffset << ", " << yoffset << ", " << zoffset
+                 << ", " << width << ", " << height << ", " << depth << ", "
+                 << GLEnums::GetStringEnum(format) << ", " << imageSize << ", "
+                 << static_cast<const void*>(data) << ")");
+  gl_api_->glCompressedTexSubImage3DFn(target, level, xoffset, yoffset, zoffset,
+                                       width, height, depth, format, imageSize,
+                                       data);
+}
+
+void DebugGLApi::glCopyBufferSubDataFn(GLenum readTarget,
+                                       GLenum writeTarget,
+                                       GLintptr readOffset,
+                                       GLintptr writeOffset,
+                                       GLsizeiptr size) {
+  GL_SERVICE_LOG("glCopyBufferSubData"
+                 << "(" << GLEnums::GetStringEnum(readTarget) << ", "
+                 << GLEnums::GetStringEnum(writeTarget) << ", " << readOffset
+                 << ", " << writeOffset << ", " << size << ")");
+  gl_api_->glCopyBufferSubDataFn(readTarget, writeTarget, readOffset,
+                                 writeOffset, size);
+}
+
+void DebugGLApi::glCopySubTextureCHROMIUMFn(GLuint sourceId,
+                                            GLuint destId,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLboolean unpackFlipY,
+                                            GLboolean unpackPremultiplyAlpha,
+                                            GLboolean unpackUnmultiplyAlpha) {
+  GL_SERVICE_LOG("glCopySubTextureCHROMIUM"
+                 << "(" << sourceId << ", " << destId << ", " << xoffset << ", "
+                 << yoffset << ", " << x << ", " << y << ", " << width << ", "
+                 << height << ", " << GLEnums::GetStringBool(unpackFlipY)
+                 << ", " << GLEnums::GetStringBool(unpackPremultiplyAlpha)
+                 << ", " << GLEnums::GetStringBool(unpackUnmultiplyAlpha)
+                 << ")");
+  gl_api_->glCopySubTextureCHROMIUMFn(
+      sourceId, destId, xoffset, yoffset, x, y, width, height, unpackFlipY,
+      unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void DebugGLApi::glCopyTexImage2DFn(GLenum target,
+                                    GLint level,
+                                    GLenum internalformat,
+                                    GLint x,
+                                    GLint y,
+                                    GLsizei width,
+                                    GLsizei height,
+                                    GLint border) {
+  GL_SERVICE_LOG("glCopyTexImage2D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", " << x
+                 << ", " << y << ", " << width << ", " << height << ", "
+                 << border << ")");
+  gl_api_->glCopyTexImage2DFn(target, level, internalformat, x, y, width,
+                              height, border);
+}
+
+void DebugGLApi::glCopyTexSubImage2DFn(GLenum target,
+                                       GLint level,
+                                       GLint xoffset,
+                                       GLint yoffset,
+                                       GLint x,
+                                       GLint y,
+                                       GLsizei width,
+                                       GLsizei height) {
+  GL_SERVICE_LOG("glCopyTexSubImage2D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y
+                 << ", " << width << ", " << height << ")");
+  gl_api_->glCopyTexSubImage2DFn(target, level, xoffset, yoffset, x, y, width,
+                                 height);
+}
+
+void DebugGLApi::glCopyTexSubImage3DFn(GLenum target,
+                                       GLint level,
+                                       GLint xoffset,
+                                       GLint yoffset,
+                                       GLint zoffset,
+                                       GLint x,
+                                       GLint y,
+                                       GLsizei width,
+                                       GLsizei height) {
+  GL_SERVICE_LOG("glCopyTexSubImage3D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << xoffset << ", " << yoffset << ", " << zoffset
+                 << ", " << x << ", " << y << ", " << width << ", " << height
+                 << ")");
+  gl_api_->glCopyTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, x, y,
+                                 width, height);
+}
+
+void DebugGLApi::glCopyTextureCHROMIUMFn(GLuint sourceId,
+                                         GLuint destId,
+                                         GLint internalFormat,
+                                         GLenum destType,
+                                         GLboolean unpackFlipY,
+                                         GLboolean unpackPremultiplyAlpha,
+                                         GLboolean unpackUnmultiplyAlpha) {
+  GL_SERVICE_LOG("glCopyTextureCHROMIUM"
+                 << "(" << sourceId << ", " << destId << ", " << internalFormat
+                 << ", " << GLEnums::GetStringEnum(destType) << ", "
+                 << GLEnums::GetStringBool(unpackFlipY) << ", "
+                 << GLEnums::GetStringBool(unpackPremultiplyAlpha) << ", "
+                 << GLEnums::GetStringBool(unpackUnmultiplyAlpha) << ")");
+  gl_api_->glCopyTextureCHROMIUMFn(sourceId, destId, internalFormat, destType,
+                                   unpackFlipY, unpackPremultiplyAlpha,
+                                   unpackUnmultiplyAlpha);
+}
+
+void DebugGLApi::glCoverageModulationNVFn(GLenum components) {
+  GL_SERVICE_LOG("glCoverageModulationNV"
+                 << "(" << GLEnums::GetStringEnum(components) << ")");
+  gl_api_->glCoverageModulationNVFn(components);
+}
+
+void DebugGLApi::glCoverFillPathInstancedNVFn(GLsizei numPaths,
+                                              GLenum pathNameType,
+                                              const void* paths,
+                                              GLuint pathBase,
+                                              GLenum coverMode,
+                                              GLenum transformType,
+                                              const GLfloat* transformValues) {
+  GL_SERVICE_LOG("glCoverFillPathInstancedNV"
+                 << "(" << numPaths << ", "
+                 << GLEnums::GetStringEnum(pathNameType) << ", "
+                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
+                 << GLEnums::GetStringEnum(coverMode) << ", "
+                 << GLEnums::GetStringEnum(transformType) << ", "
+                 << static_cast<const void*>(transformValues) << ")");
+  gl_api_->glCoverFillPathInstancedNVFn(numPaths, pathNameType, paths, pathBase,
+                                        coverMode, transformType,
+                                        transformValues);
+}
+
+void DebugGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+  GL_SERVICE_LOG("glCoverFillPathNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(coverMode)
+                 << ")");
+  gl_api_->glCoverFillPathNVFn(path, coverMode);
+}
+
+void DebugGLApi::glCoverStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GL_SERVICE_LOG("glCoverStrokePathInstancedNV"
+                 << "(" << numPaths << ", "
+                 << GLEnums::GetStringEnum(pathNameType) << ", "
+                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
+                 << GLEnums::GetStringEnum(coverMode) << ", "
+                 << GLEnums::GetStringEnum(transformType) << ", "
+                 << static_cast<const void*>(transformValues) << ")");
+  gl_api_->glCoverStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+                                          pathBase, coverMode, transformType,
+                                          transformValues);
+}
+
+void DebugGLApi::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+  GL_SERVICE_LOG("glCoverStrokePathNV"
+                 << "(" << name << ", " << GLEnums::GetStringEnum(coverMode)
+                 << ")");
+  gl_api_->glCoverStrokePathNVFn(name, coverMode);
+}
+
+GLuint DebugGLApi::glCreateProgramFn(void) {
+  GL_SERVICE_LOG("glCreateProgram"
+                 << "("
+                 << ")");
+  GLuint result = gl_api_->glCreateProgramFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLuint DebugGLApi::glCreateShaderFn(GLenum type) {
+  GL_SERVICE_LOG("glCreateShader"
+                 << "(" << GLEnums::GetStringEnum(type) << ")");
+  GLuint result = gl_api_->glCreateShaderFn(type);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glCullFaceFn(GLenum mode) {
+  GL_SERVICE_LOG("glCullFace"
+                 << "(" << GLEnums::GetStringEnum(mode) << ")");
+  gl_api_->glCullFaceFn(mode);
+}
+
+void DebugGLApi::glDebugMessageCallbackFn(GLDEBUGPROC callback,
+                                          const void* userParam) {
+  GL_SERVICE_LOG("glDebugMessageCallback"
+                 << "(" << callback << ", "
+                 << static_cast<const void*>(userParam) << ")");
+  gl_api_->glDebugMessageCallbackFn(callback, userParam);
+}
+
+void DebugGLApi::glDebugMessageControlFn(GLenum source,
+                                         GLenum type,
+                                         GLenum severity,
+                                         GLsizei count,
+                                         const GLuint* ids,
+                                         GLboolean enabled) {
+  GL_SERVICE_LOG("glDebugMessageControl"
+                 << "(" << GLEnums::GetStringEnum(source) << ", "
+                 << GLEnums::GetStringEnum(type) << ", "
+                 << GLEnums::GetStringEnum(severity) << ", " << count << ", "
+                 << static_cast<const void*>(ids) << ", "
+                 << GLEnums::GetStringBool(enabled) << ")");
+  gl_api_->glDebugMessageControlFn(source, type, severity, count, ids, enabled);
+}
+
+void DebugGLApi::glDebugMessageInsertFn(GLenum source,
+                                        GLenum type,
+                                        GLuint id,
+                                        GLenum severity,
+                                        GLsizei length,
+                                        const char* buf) {
+  GL_SERVICE_LOG("glDebugMessageInsert"
+                 << "(" << GLEnums::GetStringEnum(source) << ", "
+                 << GLEnums::GetStringEnum(type) << ", " << id << ", "
+                 << GLEnums::GetStringEnum(severity) << ", " << length << ", "
+                 << buf << ")");
+  gl_api_->glDebugMessageInsertFn(source, type, id, severity, length, buf);
+}
+
+void DebugGLApi::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
+  GL_SERVICE_LOG("glDeleteBuffersARB"
+                 << "(" << n << ", " << static_cast<const void*>(buffers)
+                 << ")");
+  gl_api_->glDeleteBuffersARBFn(n, buffers);
+}
+
+void DebugGLApi::glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) {
+  GL_SERVICE_LOG("glDeleteFencesAPPLE"
+                 << "(" << n << ", " << static_cast<const void*>(fences)
+                 << ")");
+  gl_api_->glDeleteFencesAPPLEFn(n, fences);
+}
+
+void DebugGLApi::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
+  GL_SERVICE_LOG("glDeleteFencesNV"
+                 << "(" << n << ", " << static_cast<const void*>(fences)
+                 << ")");
+  gl_api_->glDeleteFencesNVFn(n, fences);
+}
+
+void DebugGLApi::glDeleteFramebuffersEXTFn(GLsizei n,
+                                           const GLuint* framebuffers) {
+  GL_SERVICE_LOG("glDeleteFramebuffersEXT"
+                 << "(" << n << ", " << static_cast<const void*>(framebuffers)
+                 << ")");
+  gl_api_->glDeleteFramebuffersEXTFn(n, framebuffers);
+}
+
+void DebugGLApi::glDeletePathsNVFn(GLuint path, GLsizei range) {
+  GL_SERVICE_LOG("glDeletePathsNV"
+                 << "(" << path << ", " << range << ")");
+  gl_api_->glDeletePathsNVFn(path, range);
+}
+
+void DebugGLApi::glDeleteProgramFn(GLuint program) {
+  GL_SERVICE_LOG("glDeleteProgram"
+                 << "(" << program << ")");
+  gl_api_->glDeleteProgramFn(program);
+}
+
+void DebugGLApi::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
+  GL_SERVICE_LOG("glDeleteQueries"
+                 << "(" << n << ", " << static_cast<const void*>(ids) << ")");
+  gl_api_->glDeleteQueriesFn(n, ids);
+}
+
+void DebugGLApi::glDeleteRenderbuffersEXTFn(GLsizei n,
+                                            const GLuint* renderbuffers) {
+  GL_SERVICE_LOG("glDeleteRenderbuffersEXT"
+                 << "(" << n << ", " << static_cast<const void*>(renderbuffers)
+                 << ")");
+  gl_api_->glDeleteRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void DebugGLApi::glDeleteSamplersFn(GLsizei n, const GLuint* samplers) {
+  GL_SERVICE_LOG("glDeleteSamplers"
+                 << "(" << n << ", " << static_cast<const void*>(samplers)
+                 << ")");
+  gl_api_->glDeleteSamplersFn(n, samplers);
+}
+
+void DebugGLApi::glDeleteShaderFn(GLuint shader) {
+  GL_SERVICE_LOG("glDeleteShader"
+                 << "(" << shader << ")");
+  gl_api_->glDeleteShaderFn(shader);
+}
+
+void DebugGLApi::glDeleteSyncFn(GLsync sync) {
+  GL_SERVICE_LOG("glDeleteSync"
+                 << "(" << sync << ")");
+  gl_api_->glDeleteSyncFn(sync);
+}
+
+void DebugGLApi::glDeleteTexturesFn(GLsizei n, const GLuint* textures) {
+  GL_SERVICE_LOG("glDeleteTextures"
+                 << "(" << n << ", " << static_cast<const void*>(textures)
+                 << ")");
+  gl_api_->glDeleteTexturesFn(n, textures);
+}
+
+void DebugGLApi::glDeleteTransformFeedbacksFn(GLsizei n, const GLuint* ids) {
+  GL_SERVICE_LOG("glDeleteTransformFeedbacks"
+                 << "(" << n << ", " << static_cast<const void*>(ids) << ")");
+  gl_api_->glDeleteTransformFeedbacksFn(n, ids);
+}
+
+void DebugGLApi::glDeleteVertexArraysOESFn(GLsizei n, const GLuint* arrays) {
+  GL_SERVICE_LOG("glDeleteVertexArraysOES"
+                 << "(" << n << ", " << static_cast<const void*>(arrays)
+                 << ")");
+  gl_api_->glDeleteVertexArraysOESFn(n, arrays);
+}
+
+void DebugGLApi::glDepthFuncFn(GLenum func) {
+  GL_SERVICE_LOG("glDepthFunc"
+                 << "(" << GLEnums::GetStringEnum(func) << ")");
+  gl_api_->glDepthFuncFn(func);
+}
+
+void DebugGLApi::glDepthMaskFn(GLboolean flag) {
+  GL_SERVICE_LOG("glDepthMask"
+                 << "(" << GLEnums::GetStringBool(flag) << ")");
+  gl_api_->glDepthMaskFn(flag);
+}
+
+void DebugGLApi::glDepthRangeFn(GLclampd zNear, GLclampd zFar) {
+  GL_SERVICE_LOG("glDepthRange"
+                 << "(" << zNear << ", " << zFar << ")");
+  gl_api_->glDepthRangeFn(zNear, zFar);
+}
+
+void DebugGLApi::glDepthRangefFn(GLclampf zNear, GLclampf zFar) {
+  GL_SERVICE_LOG("glDepthRangef"
+                 << "(" << zNear << ", " << zFar << ")");
+  gl_api_->glDepthRangefFn(zNear, zFar);
+}
+
+void DebugGLApi::glDetachShaderFn(GLuint program, GLuint shader) {
+  GL_SERVICE_LOG("glDetachShader"
+                 << "(" << program << ", " << shader << ")");
+  gl_api_->glDetachShaderFn(program, shader);
+}
+
+void DebugGLApi::glDisableFn(GLenum cap) {
+  GL_SERVICE_LOG("glDisable"
+                 << "(" << GLEnums::GetStringEnum(cap) << ")");
+  gl_api_->glDisableFn(cap);
+}
+
+void DebugGLApi::glDisableVertexAttribArrayFn(GLuint index) {
+  GL_SERVICE_LOG("glDisableVertexAttribArray"
+                 << "(" << index << ")");
+  gl_api_->glDisableVertexAttribArrayFn(index);
+}
+
+void DebugGLApi::glDiscardFramebufferEXTFn(GLenum target,
+                                           GLsizei numAttachments,
+                                           const GLenum* attachments) {
+  GL_SERVICE_LOG("glDiscardFramebufferEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << numAttachments << ", "
+                 << static_cast<const void*>(attachments) << ")");
+  gl_api_->glDiscardFramebufferEXTFn(target, numAttachments, attachments);
+}
+
+void DebugGLApi::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
+  GL_SERVICE_LOG("glDrawArrays"
+                 << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", "
+                 << count << ")");
+  gl_api_->glDrawArraysFn(mode, first, count);
+}
+
+void DebugGLApi::glDrawArraysInstancedANGLEFn(GLenum mode,
+                                              GLint first,
+                                              GLsizei count,
+                                              GLsizei primcount) {
+  GL_SERVICE_LOG("glDrawArraysInstancedANGLE"
+                 << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", "
+                 << count << ", " << primcount << ")");
+  gl_api_->glDrawArraysInstancedANGLEFn(mode, first, count, primcount);
+}
+
+void DebugGLApi::glDrawBufferFn(GLenum mode) {
+  GL_SERVICE_LOG("glDrawBuffer"
+                 << "(" << GLEnums::GetStringEnum(mode) << ")");
+  gl_api_->glDrawBufferFn(mode);
+}
+
+void DebugGLApi::glDrawBuffersARBFn(GLsizei n, const GLenum* bufs) {
+  GL_SERVICE_LOG("glDrawBuffersARB"
+                 << "(" << n << ", " << static_cast<const void*>(bufs) << ")");
+  gl_api_->glDrawBuffersARBFn(n, bufs);
+}
+
+void DebugGLApi::glDrawElementsFn(GLenum mode,
+                                  GLsizei count,
+                                  GLenum type,
+                                  const void* indices) {
+  GL_SERVICE_LOG("glDrawElements"
+                 << "(" << GLEnums::GetStringEnum(mode) << ", " << count << ", "
+                 << GLEnums::GetStringEnum(type) << ", "
+                 << static_cast<const void*>(indices) << ")");
+  gl_api_->glDrawElementsFn(mode, count, type, indices);
+}
+
+void DebugGLApi::glDrawElementsInstancedANGLEFn(GLenum mode,
+                                                GLsizei count,
+                                                GLenum type,
+                                                const void* indices,
+                                                GLsizei primcount) {
+  GL_SERVICE_LOG("glDrawElementsInstancedANGLE"
+                 << "(" << GLEnums::GetStringEnum(mode) << ", " << count << ", "
+                 << GLEnums::GetStringEnum(type) << ", "
+                 << static_cast<const void*>(indices) << ", " << primcount
+                 << ")");
+  gl_api_->glDrawElementsInstancedANGLEFn(mode, count, type, indices,
+                                          primcount);
+}
+
+void DebugGLApi::glDrawRangeElementsFn(GLenum mode,
+                                       GLuint start,
+                                       GLuint end,
+                                       GLsizei count,
+                                       GLenum type,
+                                       const void* indices) {
+  GL_SERVICE_LOG("glDrawRangeElements"
+                 << "(" << GLEnums::GetStringEnum(mode) << ", " << start << ", "
+                 << end << ", " << count << ", " << GLEnums::GetStringEnum(type)
+                 << ", " << static_cast<const void*>(indices) << ")");
+  gl_api_->glDrawRangeElementsFn(mode, start, end, count, type, indices);
+}
+
+void DebugGLApi::glEGLImageTargetRenderbufferStorageOESFn(GLenum target,
+                                                          GLeglImageOES image) {
+  GL_SERVICE_LOG("glEGLImageTargetRenderbufferStorageOES"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << image
+                 << ")");
+  gl_api_->glEGLImageTargetRenderbufferStorageOESFn(target, image);
+}
+
+void DebugGLApi::glEGLImageTargetTexture2DOESFn(GLenum target,
+                                                GLeglImageOES image) {
+  GL_SERVICE_LOG("glEGLImageTargetTexture2DOES"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << image
+                 << ")");
+  gl_api_->glEGLImageTargetTexture2DOESFn(target, image);
+}
+
+void DebugGLApi::glEnableFn(GLenum cap) {
+  GL_SERVICE_LOG("glEnable"
+                 << "(" << GLEnums::GetStringEnum(cap) << ")");
+  gl_api_->glEnableFn(cap);
+}
+
+void DebugGLApi::glEnableVertexAttribArrayFn(GLuint index) {
+  GL_SERVICE_LOG("glEnableVertexAttribArray"
+                 << "(" << index << ")");
+  gl_api_->glEnableVertexAttribArrayFn(index);
+}
+
+void DebugGLApi::glEndQueryFn(GLenum target) {
+  GL_SERVICE_LOG("glEndQuery"
+                 << "(" << GLEnums::GetStringEnum(target) << ")");
+  gl_api_->glEndQueryFn(target);
+}
+
+void DebugGLApi::glEndTransformFeedbackFn(void) {
+  GL_SERVICE_LOG("glEndTransformFeedback"
+                 << "("
+                 << ")");
+  gl_api_->glEndTransformFeedbackFn();
+}
+
+GLsync DebugGLApi::glFenceSyncFn(GLenum condition, GLbitfield flags) {
+  GL_SERVICE_LOG("glFenceSync"
+                 << "(" << GLEnums::GetStringEnum(condition) << ", " << flags
+                 << ")");
+  GLsync result = gl_api_->glFenceSyncFn(condition, flags);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glFinishFn(void) {
+  GL_SERVICE_LOG("glFinish"
+                 << "("
+                 << ")");
+  gl_api_->glFinishFn();
+}
+
+void DebugGLApi::glFinishFenceAPPLEFn(GLuint fence) {
+  GL_SERVICE_LOG("glFinishFenceAPPLE"
+                 << "(" << fence << ")");
+  gl_api_->glFinishFenceAPPLEFn(fence);
+}
+
+void DebugGLApi::glFinishFenceNVFn(GLuint fence) {
+  GL_SERVICE_LOG("glFinishFenceNV"
+                 << "(" << fence << ")");
+  gl_api_->glFinishFenceNVFn(fence);
+}
+
+void DebugGLApi::glFlushFn(void) {
+  GL_SERVICE_LOG("glFlush"
+                 << "("
+                 << ")");
+  gl_api_->glFlushFn();
+}
+
+void DebugGLApi::glFlushMappedBufferRangeFn(GLenum target,
+                                            GLintptr offset,
+                                            GLsizeiptr length) {
+  GL_SERVICE_LOG("glFlushMappedBufferRange"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << offset
+                 << ", " << length << ")");
+  gl_api_->glFlushMappedBufferRangeFn(target, offset, length);
+}
+
+void DebugGLApi::glFramebufferRenderbufferEXTFn(GLenum target,
+                                                GLenum attachment,
+                                                GLenum renderbuffertarget,
+                                                GLuint renderbuffer) {
+  GL_SERVICE_LOG("glFramebufferRenderbufferEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(attachment) << ", "
+                 << GLEnums::GetStringEnum(renderbuffertarget) << ", "
+                 << renderbuffer << ")");
+  gl_api_->glFramebufferRenderbufferEXTFn(target, attachment,
+                                          renderbuffertarget, renderbuffer);
+}
+
+void DebugGLApi::glFramebufferTexture2DEXTFn(GLenum target,
+                                             GLenum attachment,
+                                             GLenum textarget,
+                                             GLuint texture,
+                                             GLint level) {
+  GL_SERVICE_LOG("glFramebufferTexture2DEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(attachment) << ", "
+                 << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
+                 << level << ")");
+  gl_api_->glFramebufferTexture2DEXTFn(target, attachment, textarget, texture,
+                                       level);
+}
+
+void DebugGLApi::glFramebufferTexture2DMultisampleEXTFn(GLenum target,
+                                                        GLenum attachment,
+                                                        GLenum textarget,
+                                                        GLuint texture,
+                                                        GLint level,
+                                                        GLsizei samples) {
+  GL_SERVICE_LOG("glFramebufferTexture2DMultisampleEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(attachment) << ", "
+                 << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
+                 << level << ", " << samples << ")");
+  gl_api_->glFramebufferTexture2DMultisampleEXTFn(target, attachment, textarget,
+                                                  texture, level, samples);
+}
+
+void DebugGLApi::glFramebufferTexture2DMultisampleIMGFn(GLenum target,
+                                                        GLenum attachment,
+                                                        GLenum textarget,
+                                                        GLuint texture,
+                                                        GLint level,
+                                                        GLsizei samples) {
+  GL_SERVICE_LOG("glFramebufferTexture2DMultisampleIMG"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(attachment) << ", "
+                 << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
+                 << level << ", " << samples << ")");
+  gl_api_->glFramebufferTexture2DMultisampleIMGFn(target, attachment, textarget,
+                                                  texture, level, samples);
+}
+
+void DebugGLApi::glFramebufferTextureLayerFn(GLenum target,
+                                             GLenum attachment,
+                                             GLuint texture,
+                                             GLint level,
+                                             GLint layer) {
+  GL_SERVICE_LOG("glFramebufferTextureLayer"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(attachment) << ", " << texture
+                 << ", " << level << ", " << layer << ")");
+  gl_api_->glFramebufferTextureLayerFn(target, attachment, texture, level,
+                                       layer);
+}
+
+void DebugGLApi::glFrontFaceFn(GLenum mode) {
+  GL_SERVICE_LOG("glFrontFace"
+                 << "(" << GLEnums::GetStringEnum(mode) << ")");
+  gl_api_->glFrontFaceFn(mode);
+}
+
+void DebugGLApi::glGenBuffersARBFn(GLsizei n, GLuint* buffers) {
+  GL_SERVICE_LOG("glGenBuffersARB"
+                 << "(" << n << ", " << static_cast<const void*>(buffers)
+                 << ")");
+  gl_api_->glGenBuffersARBFn(n, buffers);
+}
+
+void DebugGLApi::glGenerateMipmapEXTFn(GLenum target) {
+  GL_SERVICE_LOG("glGenerateMipmapEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ")");
+  gl_api_->glGenerateMipmapEXTFn(target);
+}
+
+void DebugGLApi::glGenFencesAPPLEFn(GLsizei n, GLuint* fences) {
+  GL_SERVICE_LOG("glGenFencesAPPLE"
+                 << "(" << n << ", " << static_cast<const void*>(fences)
+                 << ")");
+  gl_api_->glGenFencesAPPLEFn(n, fences);
+}
+
+void DebugGLApi::glGenFencesNVFn(GLsizei n, GLuint* fences) {
+  GL_SERVICE_LOG("glGenFencesNV"
+                 << "(" << n << ", " << static_cast<const void*>(fences)
+                 << ")");
+  gl_api_->glGenFencesNVFn(n, fences);
+}
+
+void DebugGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
+  GL_SERVICE_LOG("glGenFramebuffersEXT"
+                 << "(" << n << ", " << static_cast<const void*>(framebuffers)
+                 << ")");
+  gl_api_->glGenFramebuffersEXTFn(n, framebuffers);
+}
+
+GLuint DebugGLApi::glGenPathsNVFn(GLsizei range) {
+  GL_SERVICE_LOG("glGenPathsNV"
+                 << "(" << range << ")");
+  GLuint result = gl_api_->glGenPathsNVFn(range);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
+  GL_SERVICE_LOG("glGenQueries"
+                 << "(" << n << ", " << static_cast<const void*>(ids) << ")");
+  gl_api_->glGenQueriesFn(n, ids);
+}
+
+void DebugGLApi::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
+  GL_SERVICE_LOG("glGenRenderbuffersEXT"
+                 << "(" << n << ", " << static_cast<const void*>(renderbuffers)
+                 << ")");
+  gl_api_->glGenRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void DebugGLApi::glGenSamplersFn(GLsizei n, GLuint* samplers) {
+  GL_SERVICE_LOG("glGenSamplers"
+                 << "(" << n << ", " << static_cast<const void*>(samplers)
+                 << ")");
+  gl_api_->glGenSamplersFn(n, samplers);
+}
+
+void DebugGLApi::glGenTexturesFn(GLsizei n, GLuint* textures) {
+  GL_SERVICE_LOG("glGenTextures"
+                 << "(" << n << ", " << static_cast<const void*>(textures)
+                 << ")");
+  gl_api_->glGenTexturesFn(n, textures);
+}
+
+void DebugGLApi::glGenTransformFeedbacksFn(GLsizei n, GLuint* ids) {
+  GL_SERVICE_LOG("glGenTransformFeedbacks"
+                 << "(" << n << ", " << static_cast<const void*>(ids) << ")");
+  gl_api_->glGenTransformFeedbacksFn(n, ids);
+}
+
+void DebugGLApi::glGenVertexArraysOESFn(GLsizei n, GLuint* arrays) {
+  GL_SERVICE_LOG("glGenVertexArraysOES"
+                 << "(" << n << ", " << static_cast<const void*>(arrays)
+                 << ")");
+  gl_api_->glGenVertexArraysOESFn(n, arrays);
+}
+
+void DebugGLApi::glGetActiveAttribFn(GLuint program,
+                                     GLuint index,
+                                     GLsizei bufsize,
+                                     GLsizei* length,
+                                     GLint* size,
+                                     GLenum* type,
+                                     char* name) {
+  GL_SERVICE_LOG("glGetActiveAttrib"
+                 << "(" << program << ", " << index << ", " << bufsize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(size) << ", "
+                 << static_cast<const void*>(type) << ", "
+                 << static_cast<const void*>(name) << ")");
+  gl_api_->glGetActiveAttribFn(program, index, bufsize, length, size, type,
+                               name);
+}
+
+void DebugGLApi::glGetActiveUniformFn(GLuint program,
+                                      GLuint index,
+                                      GLsizei bufsize,
+                                      GLsizei* length,
+                                      GLint* size,
+                                      GLenum* type,
+                                      char* name) {
+  GL_SERVICE_LOG("glGetActiveUniform"
+                 << "(" << program << ", " << index << ", " << bufsize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(size) << ", "
+                 << static_cast<const void*>(type) << ", "
+                 << static_cast<const void*>(name) << ")");
+  gl_api_->glGetActiveUniformFn(program, index, bufsize, length, size, type,
+                                name);
+}
+
+void DebugGLApi::glGetActiveUniformBlockivFn(GLuint program,
+                                             GLuint uniformBlockIndex,
+                                             GLenum pname,
+                                             GLint* params) {
+  GL_SERVICE_LOG("glGetActiveUniformBlockiv"
+                 << "(" << program << ", " << uniformBlockIndex << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetActiveUniformBlockivFn(program, uniformBlockIndex, pname,
+                                       params);
+}
+
+void DebugGLApi::glGetActiveUniformBlockivRobustANGLEFn(
+    GLuint program,
+    GLuint uniformBlockIndex,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei* length,
+    GLint* params) {
+  GL_SERVICE_LOG("glGetActiveUniformBlockivRobustANGLE"
+                 << "(" << program << ", " << uniformBlockIndex << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetActiveUniformBlockivRobustANGLEFn(
+      program, uniformBlockIndex, pname, bufSize, length, params);
+}
+
+void DebugGLApi::glGetActiveUniformBlockNameFn(GLuint program,
+                                               GLuint uniformBlockIndex,
+                                               GLsizei bufSize,
+                                               GLsizei* length,
+                                               char* uniformBlockName) {
+  GL_SERVICE_LOG("glGetActiveUniformBlockName"
+                 << "(" << program << ", " << uniformBlockIndex << ", "
+                 << bufSize << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(uniformBlockName) << ")");
+  gl_api_->glGetActiveUniformBlockNameFn(program, uniformBlockIndex, bufSize,
+                                         length, uniformBlockName);
+}
+
+void DebugGLApi::glGetActiveUniformsivFn(GLuint program,
+                                         GLsizei uniformCount,
+                                         const GLuint* uniformIndices,
+                                         GLenum pname,
+                                         GLint* params) {
+  GL_SERVICE_LOG("glGetActiveUniformsiv"
+                 << "(" << program << ", " << uniformCount << ", "
+                 << static_cast<const void*>(uniformIndices) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetActiveUniformsivFn(program, uniformCount, uniformIndices, pname,
+                                   params);
+}
+
+void DebugGLApi::glGetAttachedShadersFn(GLuint program,
+                                        GLsizei maxcount,
+                                        GLsizei* count,
+                                        GLuint* shaders) {
+  GL_SERVICE_LOG("glGetAttachedShaders"
+                 << "(" << program << ", " << maxcount << ", "
+                 << static_cast<const void*>(count) << ", "
+                 << static_cast<const void*>(shaders) << ")");
+  gl_api_->glGetAttachedShadersFn(program, maxcount, count, shaders);
+}
+
+GLint DebugGLApi::glGetAttribLocationFn(GLuint program, const char* name) {
+  GL_SERVICE_LOG("glGetAttribLocation"
+                 << "(" << program << ", " << name << ")");
+  GLint result = gl_api_->glGetAttribLocationFn(program, name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glGetBooleani_vRobustANGLEFn(GLenum target,
+                                              GLuint index,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              GLboolean* data) {
+  GL_SERVICE_LOG("glGetBooleani_vRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(data) << ")");
+  gl_api_->glGetBooleani_vRobustANGLEFn(target, index, bufSize, length, data);
+}
+
+void DebugGLApi::glGetBooleanvFn(GLenum pname, GLboolean* params) {
+  GL_SERVICE_LOG("glGetBooleanv"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetBooleanvFn(pname, params);
+}
+
+void DebugGLApi::glGetBooleanvRobustANGLEFn(GLenum pname,
+                                            GLsizei bufSize,
+                                            GLsizei* length,
+                                            GLboolean* data) {
+  GL_SERVICE_LOG("glGetBooleanvRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(data) << ")");
+  gl_api_->glGetBooleanvRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void DebugGLApi::glGetBufferParameteri64vRobustANGLEFn(GLenum target,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLint64* params) {
+  GL_SERVICE_LOG("glGetBufferParameteri64vRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetBufferParameteri64vRobustANGLEFn(target, pname, bufSize, length,
+                                                 params);
+}
+
+void DebugGLApi::glGetBufferParameterivFn(GLenum target,
+                                          GLenum pname,
+                                          GLint* params) {
+  GL_SERVICE_LOG("glGetBufferParameteriv"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetBufferParameterivFn(target, pname, params);
+}
+
+void DebugGLApi::glGetBufferParameterivRobustANGLEFn(GLenum target,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLint* params) {
+  GL_SERVICE_LOG("glGetBufferParameterivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetBufferParameterivRobustANGLEFn(target, pname, bufSize, length,
+                                               params);
+}
+
+void DebugGLApi::glGetBufferPointervRobustANGLEFn(GLenum target,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  void** params) {
+  GL_SERVICE_LOG("glGetBufferPointervRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", " << params << ")");
+  gl_api_->glGetBufferPointervRobustANGLEFn(target, pname, bufSize, length,
+                                            params);
+}
+
+void DebugGLApi::glGetDebugMessageLogFn(GLuint count,
+                                        GLsizei bufSize,
+                                        GLenum* sources,
+                                        GLenum* types,
+                                        GLuint* ids,
+                                        GLenum* severities,
+                                        GLsizei* lengths,
+                                        char* messageLog) {
+  GL_SERVICE_LOG("glGetDebugMessageLog"
+                 << "(" << count << ", " << bufSize << ", "
+                 << static_cast<const void*>(sources) << ", "
+                 << static_cast<const void*>(types) << ", "
+                 << static_cast<const void*>(ids) << ", "
+                 << static_cast<const void*>(severities) << ", "
+                 << static_cast<const void*>(lengths) << ", "
+                 << static_cast<const void*>(messageLog) << ")");
+  gl_api_->glGetDebugMessageLogFn(count, bufSize, sources, types, ids,
+                                  severities, lengths, messageLog);
+}
+
+GLenum DebugGLApi::glGetErrorFn(void) {
+  GL_SERVICE_LOG("glGetError"
+                 << "("
+                 << ")");
+  GLenum result = gl_api_->glGetErrorFn();
+
+  GL_SERVICE_LOG("GL_RESULT: " << GLEnums::GetStringError(result));
+
+  return result;
+}
+
+void DebugGLApi::glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) {
+  GL_SERVICE_LOG("glGetFenceivNV"
+                 << "(" << fence << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetFenceivNVFn(fence, pname, params);
+}
+
+void DebugGLApi::glGetFloatvFn(GLenum pname, GLfloat* params) {
+  GL_SERVICE_LOG("glGetFloatv"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetFloatvFn(pname, params);
+}
+
+void DebugGLApi::glGetFloatvRobustANGLEFn(GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei* length,
+                                          GLfloat* data) {
+  GL_SERVICE_LOG("glGetFloatvRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(data) << ")");
+  gl_api_->glGetFloatvRobustANGLEFn(pname, bufSize, length, data);
+}
+
+GLint DebugGLApi::glGetFragDataIndexFn(GLuint program, const char* name) {
+  GL_SERVICE_LOG("glGetFragDataIndex"
+                 << "(" << program << ", " << name << ")");
+  GLint result = gl_api_->glGetFragDataIndexFn(program, name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLint DebugGLApi::glGetFragDataLocationFn(GLuint program, const char* name) {
+  GL_SERVICE_LOG("glGetFragDataLocation"
+                 << "(" << program << ", " << name << ")");
+  GLint result = gl_api_->glGetFragDataLocationFn(program, name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glGetFramebufferAttachmentParameterivEXTFn(GLenum target,
+                                                            GLenum attachment,
+                                                            GLenum pname,
+                                                            GLint* params) {
+  GL_SERVICE_LOG("glGetFramebufferAttachmentParameterivEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(attachment) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetFramebufferAttachmentParameterivEXTFn(target, attachment, pname,
+                                                      params);
+}
+
+void DebugGLApi::glGetFramebufferAttachmentParameterivRobustANGLEFn(
+    GLenum target,
+    GLenum attachment,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei* length,
+    GLint* params) {
+  GL_SERVICE_LOG("glGetFramebufferAttachmentParameterivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(attachment) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetFramebufferAttachmentParameterivRobustANGLEFn(
+      target, attachment, pname, bufSize, length, params);
+}
+
+void DebugGLApi::glGetFramebufferParameterivRobustANGLEFn(GLenum target,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei* length,
+                                                          GLint* params) {
+  GL_SERVICE_LOG("glGetFramebufferParameterivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetFramebufferParameterivRobustANGLEFn(target, pname, bufSize,
+                                                    length, params);
+}
+
+GLenum DebugGLApi::glGetGraphicsResetStatusARBFn(void) {
+  GL_SERVICE_LOG("glGetGraphicsResetStatusARB"
+                 << "("
+                 << ")");
+  GLenum result = gl_api_->glGetGraphicsResetStatusARBFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glGetInteger64i_vFn(GLenum target,
+                                     GLuint index,
+                                     GLint64* data) {
+  GL_SERVICE_LOG("glGetInteger64i_v"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
+                 << ", " << static_cast<const void*>(data) << ")");
+  gl_api_->glGetInteger64i_vFn(target, index, data);
+}
+
+void DebugGLApi::glGetInteger64i_vRobustANGLEFn(GLenum target,
+                                                GLuint index,
+                                                GLsizei bufSize,
+                                                GLsizei* length,
+                                                GLint64* data) {
+  GL_SERVICE_LOG("glGetInteger64i_vRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(data) << ")");
+  gl_api_->glGetInteger64i_vRobustANGLEFn(target, index, bufSize, length, data);
+}
+
+void DebugGLApi::glGetInteger64vFn(GLenum pname, GLint64* params) {
+  GL_SERVICE_LOG("glGetInteger64v"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetInteger64vFn(pname, params);
+}
+
+void DebugGLApi::glGetInteger64vRobustANGLEFn(GLenum pname,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              GLint64* data) {
+  GL_SERVICE_LOG("glGetInteger64vRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(data) << ")");
+  gl_api_->glGetInteger64vRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void DebugGLApi::glGetIntegeri_vFn(GLenum target, GLuint index, GLint* data) {
+  GL_SERVICE_LOG("glGetIntegeri_v"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
+                 << ", " << static_cast<const void*>(data) << ")");
+  gl_api_->glGetIntegeri_vFn(target, index, data);
+}
+
+void DebugGLApi::glGetIntegeri_vRobustANGLEFn(GLenum target,
+                                              GLuint index,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              GLint* data) {
+  GL_SERVICE_LOG("glGetIntegeri_vRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << index
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(data) << ")");
+  gl_api_->glGetIntegeri_vRobustANGLEFn(target, index, bufSize, length, data);
+}
+
+void DebugGLApi::glGetIntegervFn(GLenum pname, GLint* params) {
+  GL_SERVICE_LOG("glGetIntegerv"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetIntegervFn(pname, params);
+}
+
+void DebugGLApi::glGetIntegervRobustANGLEFn(GLenum pname,
+                                            GLsizei bufSize,
+                                            GLsizei* length,
+                                            GLint* data) {
+  GL_SERVICE_LOG("glGetIntegervRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(data) << ")");
+  gl_api_->glGetIntegervRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void DebugGLApi::glGetInternalformativFn(GLenum target,
+                                         GLenum internalformat,
+                                         GLenum pname,
+                                         GLsizei bufSize,
+                                         GLint* params) {
+  GL_SERVICE_LOG("glGetInternalformativ"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(internalformat) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetInternalformativFn(target, internalformat, pname, bufSize,
+                                   params);
+}
+
+void DebugGLApi::glGetInternalformativRobustANGLEFn(GLenum target,
+                                                    GLenum internalformat,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei* length,
+                                                    GLint* params) {
+  GL_SERVICE_LOG("glGetInternalformativRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(internalformat) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetInternalformativRobustANGLEFn(target, internalformat, pname,
+                                              bufSize, length, params);
+}
+
+void DebugGLApi::glGetMultisamplefvRobustANGLEFn(GLenum pname,
+                                                 GLuint index,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLfloat* val) {
+  GL_SERVICE_LOG("glGetMultisamplefvRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << index
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(val) << ")");
+  gl_api_->glGetMultisamplefvRobustANGLEFn(pname, index, bufSize, length, val);
+}
+
+void DebugGLApi::glGetnUniformfvRobustANGLEFn(GLuint program,
+                                              GLint location,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              GLfloat* params) {
+  GL_SERVICE_LOG("glGetnUniformfvRobustANGLE"
+                 << "(" << program << ", " << location << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetnUniformfvRobustANGLEFn(program, location, bufSize, length,
+                                        params);
+}
+
+void DebugGLApi::glGetnUniformivRobustANGLEFn(GLuint program,
+                                              GLint location,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              GLint* params) {
+  GL_SERVICE_LOG("glGetnUniformivRobustANGLE"
+                 << "(" << program << ", " << location << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetnUniformivRobustANGLEFn(program, location, bufSize, length,
+                                        params);
+}
+
+void DebugGLApi::glGetnUniformuivRobustANGLEFn(GLuint program,
+                                               GLint location,
+                                               GLsizei bufSize,
+                                               GLsizei* length,
+                                               GLuint* params) {
+  GL_SERVICE_LOG("glGetnUniformuivRobustANGLE"
+                 << "(" << program << ", " << location << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetnUniformuivRobustANGLEFn(program, location, bufSize, length,
+                                         params);
+}
+
+void DebugGLApi::glGetObjectLabelFn(GLenum identifier,
+                                    GLuint name,
+                                    GLsizei bufSize,
+                                    GLsizei* length,
+                                    char* label) {
+  GL_SERVICE_LOG("glGetObjectLabel"
+                 << "(" << GLEnums::GetStringEnum(identifier) << ", " << name
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(label) << ")");
+  gl_api_->glGetObjectLabelFn(identifier, name, bufSize, length, label);
+}
+
+void DebugGLApi::glGetObjectPtrLabelFn(void* ptr,
+                                       GLsizei bufSize,
+                                       GLsizei* length,
+                                       char* label) {
+  GL_SERVICE_LOG("glGetObjectPtrLabel"
+                 << "(" << static_cast<const void*>(ptr) << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(label) << ")");
+  gl_api_->glGetObjectPtrLabelFn(ptr, bufSize, length, label);
+}
+
+void DebugGLApi::glGetPointervFn(GLenum pname, void** params) {
+  GL_SERVICE_LOG("glGetPointerv"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << params
+                 << ")");
+  gl_api_->glGetPointervFn(pname, params);
+}
+
+void DebugGLApi::glGetPointervRobustANGLERobustANGLEFn(GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       void** params) {
+  GL_SERVICE_LOG("glGetPointervRobustANGLERobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", " << params
+                 << ")");
+  gl_api_->glGetPointervRobustANGLERobustANGLEFn(pname, bufSize, length,
+                                                 params);
+}
+
+void DebugGLApi::glGetProgramBinaryFn(GLuint program,
+                                      GLsizei bufSize,
+                                      GLsizei* length,
+                                      GLenum* binaryFormat,
+                                      GLvoid* binary) {
+  GL_SERVICE_LOG("glGetProgramBinary"
+                 << "(" << program << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(binaryFormat) << ", "
+                 << static_cast<const void*>(binary) << ")");
+  gl_api_->glGetProgramBinaryFn(program, bufSize, length, binaryFormat, binary);
+}
+
+void DebugGLApi::glGetProgramInfoLogFn(GLuint program,
+                                       GLsizei bufsize,
+                                       GLsizei* length,
+                                       char* infolog) {
+  GL_SERVICE_LOG("glGetProgramInfoLog"
+                 << "(" << program << ", " << bufsize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(infolog) << ")");
+  gl_api_->glGetProgramInfoLogFn(program, bufsize, length, infolog);
+}
+
+void DebugGLApi::glGetProgramInterfaceivFn(GLuint program,
+                                           GLenum programInterface,
+                                           GLenum pname,
+                                           GLint* params) {
+  GL_SERVICE_LOG("glGetProgramInterfaceiv"
+                 << "(" << program << ", "
+                 << GLEnums::GetStringEnum(programInterface) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetProgramInterfaceivFn(program, programInterface, pname, params);
+}
+
+void DebugGLApi::glGetProgramInterfaceivRobustANGLEFn(GLuint program,
+                                                      GLenum programInterface,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLint* params) {
+  GL_SERVICE_LOG("glGetProgramInterfaceivRobustANGLE"
+                 << "(" << program << ", "
+                 << GLEnums::GetStringEnum(programInterface) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetProgramInterfaceivRobustANGLEFn(program, programInterface,
+                                                pname, bufSize, length, params);
+}
+
+void DebugGLApi::glGetProgramivFn(GLuint program, GLenum pname, GLint* params) {
+  GL_SERVICE_LOG("glGetProgramiv"
+                 << "(" << program << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetProgramivFn(program, pname, params);
+}
+
+void DebugGLApi::glGetProgramivRobustANGLEFn(GLuint program,
+                                             GLenum pname,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLint* params) {
+  GL_SERVICE_LOG("glGetProgramivRobustANGLE"
+                 << "(" << program << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetProgramivRobustANGLEFn(program, pname, bufSize, length, params);
+}
+
+void DebugGLApi::glGetProgramResourceivFn(GLuint program,
+                                          GLenum programInterface,
+                                          GLuint index,
+                                          GLsizei propCount,
+                                          const GLenum* props,
+                                          GLsizei bufSize,
+                                          GLsizei* length,
+                                          GLint* params) {
+  GL_SERVICE_LOG("glGetProgramResourceiv"
+                 << "(" << program << ", "
+                 << GLEnums::GetStringEnum(programInterface) << ", " << index
+                 << ", " << propCount << ", " << static_cast<const void*>(props)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetProgramResourceivFn(program, programInterface, index, propCount,
+                                    props, bufSize, length, params);
+}
+
+GLint DebugGLApi::glGetProgramResourceLocationFn(GLuint program,
+                                                 GLenum programInterface,
+                                                 const char* name) {
+  GL_SERVICE_LOG("glGetProgramResourceLocation"
+                 << "(" << program << ", "
+                 << GLEnums::GetStringEnum(programInterface) << ", " << name
+                 << ")");
+  GLint result =
+      gl_api_->glGetProgramResourceLocationFn(program, programInterface, name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glGetProgramResourceNameFn(GLuint program,
+                                            GLenum programInterface,
+                                            GLuint index,
+                                            GLsizei bufSize,
+                                            GLsizei* length,
+                                            GLchar* name) {
+  GL_SERVICE_LOG("glGetProgramResourceName"
+                 << "(" << program << ", "
+                 << GLEnums::GetStringEnum(programInterface) << ", " << index
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(name) << ")");
+  gl_api_->glGetProgramResourceNameFn(program, programInterface, index, bufSize,
+                                      length, name);
+}
+
+void DebugGLApi::glGetQueryivFn(GLenum target, GLenum pname, GLint* params) {
+  GL_SERVICE_LOG("glGetQueryiv"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryivFn(target, pname, params);
+}
+
+void DebugGLApi::glGetQueryivRobustANGLEFn(GLenum target,
+                                           GLenum pname,
+                                           GLsizei bufSize,
+                                           GLsizei* length,
+                                           GLint* params) {
+  GL_SERVICE_LOG("glGetQueryivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryivRobustANGLEFn(target, pname, bufSize, length, params);
+}
+
+void DebugGLApi::glGetQueryObjecti64vFn(GLuint id,
+                                        GLenum pname,
+                                        GLint64* params) {
+  GL_SERVICE_LOG("glGetQueryObjecti64v"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryObjecti64vFn(id, pname, params);
+}
+
+void DebugGLApi::glGetQueryObjecti64vRobustANGLEFn(GLuint id,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei* length,
+                                                   GLint64* params) {
+  GL_SERVICE_LOG("glGetQueryObjecti64vRobustANGLE"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << bufSize << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryObjecti64vRobustANGLEFn(id, pname, bufSize, length,
+                                             params);
+}
+
+void DebugGLApi::glGetQueryObjectivFn(GLuint id, GLenum pname, GLint* params) {
+  GL_SERVICE_LOG("glGetQueryObjectiv"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryObjectivFn(id, pname, params);
+}
+
+void DebugGLApi::glGetQueryObjectivRobustANGLEFn(GLuint id,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLint* params) {
+  GL_SERVICE_LOG("glGetQueryObjectivRobustANGLE"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << bufSize << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryObjectivRobustANGLEFn(id, pname, bufSize, length, params);
+}
+
+void DebugGLApi::glGetQueryObjectui64vFn(GLuint id,
+                                         GLenum pname,
+                                         GLuint64* params) {
+  GL_SERVICE_LOG("glGetQueryObjectui64v"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryObjectui64vFn(id, pname, params);
+}
+
+void DebugGLApi::glGetQueryObjectui64vRobustANGLEFn(GLuint id,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei* length,
+                                                    GLuint64* params) {
+  GL_SERVICE_LOG("glGetQueryObjectui64vRobustANGLE"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << bufSize << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryObjectui64vRobustANGLEFn(id, pname, bufSize, length,
+                                              params);
+}
+
+void DebugGLApi::glGetQueryObjectuivFn(GLuint id,
+                                       GLenum pname,
+                                       GLuint* params) {
+  GL_SERVICE_LOG("glGetQueryObjectuiv"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryObjectuivFn(id, pname, params);
+}
+
+void DebugGLApi::glGetQueryObjectuivRobustANGLEFn(GLuint id,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLuint* params) {
+  GL_SERVICE_LOG("glGetQueryObjectuivRobustANGLE"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << bufSize << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetQueryObjectuivRobustANGLEFn(id, pname, bufSize, length, params);
+}
+
+void DebugGLApi::glGetRenderbufferParameterivEXTFn(GLenum target,
+                                                   GLenum pname,
+                                                   GLint* params) {
+  GL_SERVICE_LOG("glGetRenderbufferParameterivEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetRenderbufferParameterivEXTFn(target, pname, params);
+}
+
+void DebugGLApi::glGetRenderbufferParameterivRobustANGLEFn(GLenum target,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei* length,
+                                                           GLint* params) {
+  GL_SERVICE_LOG("glGetRenderbufferParameterivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetRenderbufferParameterivRobustANGLEFn(target, pname, bufSize,
+                                                     length, params);
+}
+
+void DebugGLApi::glGetSamplerParameterfvFn(GLuint sampler,
+                                           GLenum pname,
+                                           GLfloat* params) {
+  GL_SERVICE_LOG("glGetSamplerParameterfv"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetSamplerParameterfvFn(sampler, pname, params);
+}
+
+void DebugGLApi::glGetSamplerParameterfvRobustANGLEFn(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLfloat* params) {
+  GL_SERVICE_LOG("glGetSamplerParameterfvRobustANGLE"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, length,
+                                                params);
+}
+
+void DebugGLApi::glGetSamplerParameterIivRobustANGLEFn(GLuint sampler,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLint* params) {
+  GL_SERVICE_LOG("glGetSamplerParameterIivRobustANGLE"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize,
+                                                 length, params);
+}
+
+void DebugGLApi::glGetSamplerParameterIuivRobustANGLEFn(GLuint sampler,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei* length,
+                                                        GLuint* params) {
+  GL_SERVICE_LOG("glGetSamplerParameterIuivRobustANGLE"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize,
+                                                  length, params);
+}
+
+void DebugGLApi::glGetSamplerParameterivFn(GLuint sampler,
+                                           GLenum pname,
+                                           GLint* params) {
+  GL_SERVICE_LOG("glGetSamplerParameteriv"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetSamplerParameterivFn(sampler, pname, params);
+}
+
+void DebugGLApi::glGetSamplerParameterivRobustANGLEFn(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLint* params) {
+  GL_SERVICE_LOG("glGetSamplerParameterivRobustANGLE"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, length,
+                                                params);
+}
+
+void DebugGLApi::glGetShaderInfoLogFn(GLuint shader,
+                                      GLsizei bufsize,
+                                      GLsizei* length,
+                                      char* infolog) {
+  GL_SERVICE_LOG("glGetShaderInfoLog"
+                 << "(" << shader << ", " << bufsize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(infolog) << ")");
+  gl_api_->glGetShaderInfoLogFn(shader, bufsize, length, infolog);
+}
+
+void DebugGLApi::glGetShaderivFn(GLuint shader, GLenum pname, GLint* params) {
+  GL_SERVICE_LOG("glGetShaderiv"
+                 << "(" << shader << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetShaderivFn(shader, pname, params);
+}
+
+void DebugGLApi::glGetShaderivRobustANGLEFn(GLuint shader,
+                                            GLenum pname,
+                                            GLsizei bufSize,
+                                            GLsizei* length,
+                                            GLint* params) {
+  GL_SERVICE_LOG("glGetShaderivRobustANGLE"
+                 << "(" << shader << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetShaderivRobustANGLEFn(shader, pname, bufSize, length, params);
+}
+
+void DebugGLApi::glGetShaderPrecisionFormatFn(GLenum shadertype,
+                                              GLenum precisiontype,
+                                              GLint* range,
+                                              GLint* precision) {
+  GL_SERVICE_LOG("glGetShaderPrecisionFormat"
+                 << "(" << GLEnums::GetStringEnum(shadertype) << ", "
+                 << GLEnums::GetStringEnum(precisiontype) << ", "
+                 << static_cast<const void*>(range) << ", "
+                 << static_cast<const void*>(precision) << ")");
+  gl_api_->glGetShaderPrecisionFormatFn(shadertype, precisiontype, range,
+                                        precision);
+}
+
+void DebugGLApi::glGetShaderSourceFn(GLuint shader,
+                                     GLsizei bufsize,
+                                     GLsizei* length,
+                                     char* source) {
+  GL_SERVICE_LOG("glGetShaderSource"
+                 << "(" << shader << ", " << bufsize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(source) << ")");
+  gl_api_->glGetShaderSourceFn(shader, bufsize, length, source);
+}
+
+const GLubyte* DebugGLApi::glGetStringFn(GLenum name) {
+  GL_SERVICE_LOG("glGetString"
+                 << "(" << GLEnums::GetStringEnum(name) << ")");
+  const GLubyte* result = gl_api_->glGetStringFn(name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+const GLubyte* DebugGLApi::glGetStringiFn(GLenum name, GLuint index) {
+  GL_SERVICE_LOG("glGetStringi"
+                 << "(" << GLEnums::GetStringEnum(name) << ", " << index
+                 << ")");
+  const GLubyte* result = gl_api_->glGetStringiFn(name, index);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glGetSyncivFn(GLsync sync,
+                               GLenum pname,
+                               GLsizei bufSize,
+                               GLsizei* length,
+                               GLint* values) {
+  GL_SERVICE_LOG("glGetSynciv"
+                 << "(" << sync << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << bufSize << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(values) << ")");
+  gl_api_->glGetSyncivFn(sync, pname, bufSize, length, values);
+}
+
+void DebugGLApi::glGetTexLevelParameterfvFn(GLenum target,
+                                            GLint level,
+                                            GLenum pname,
+                                            GLfloat* params) {
+  GL_SERVICE_LOG("glGetTexLevelParameterfv"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexLevelParameterfvFn(target, level, pname, params);
+}
+
+void DebugGLApi::glGetTexLevelParameterfvRobustANGLEFn(GLenum target,
+                                                       GLint level,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLfloat* params) {
+  GL_SERVICE_LOG("glGetTexLevelParameterfvRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << GLEnums::GetStringEnum(pname) << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexLevelParameterfvRobustANGLEFn(target, level, pname, bufSize,
+                                                 length, params);
+}
+
+void DebugGLApi::glGetTexLevelParameterivFn(GLenum target,
+                                            GLint level,
+                                            GLenum pname,
+                                            GLint* params) {
+  GL_SERVICE_LOG("glGetTexLevelParameteriv"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexLevelParameterivFn(target, level, pname, params);
+}
+
+void DebugGLApi::glGetTexLevelParameterivRobustANGLEFn(GLenum target,
+                                                       GLint level,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLint* params) {
+  GL_SERVICE_LOG("glGetTexLevelParameterivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << GLEnums::GetStringEnum(pname) << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexLevelParameterivRobustANGLEFn(target, level, pname, bufSize,
+                                                 length, params);
+}
+
+void DebugGLApi::glGetTexParameterfvFn(GLenum target,
+                                       GLenum pname,
+                                       GLfloat* params) {
+  GL_SERVICE_LOG("glGetTexParameterfv"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexParameterfvFn(target, pname, params);
+}
+
+void DebugGLApi::glGetTexParameterfvRobustANGLEFn(GLenum target,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLfloat* params) {
+  GL_SERVICE_LOG("glGetTexParameterfvRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexParameterfvRobustANGLEFn(target, pname, bufSize, length,
+                                            params);
+}
+
+void DebugGLApi::glGetTexParameterIivRobustANGLEFn(GLenum target,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei* length,
+                                                   GLint* params) {
+  GL_SERVICE_LOG("glGetTexParameterIivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexParameterIivRobustANGLEFn(target, pname, bufSize, length,
+                                             params);
+}
+
+void DebugGLApi::glGetTexParameterIuivRobustANGLEFn(GLenum target,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei* length,
+                                                    GLuint* params) {
+  GL_SERVICE_LOG("glGetTexParameterIuivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexParameterIuivRobustANGLEFn(target, pname, bufSize, length,
+                                              params);
+}
+
+void DebugGLApi::glGetTexParameterivFn(GLenum target,
+                                       GLenum pname,
+                                       GLint* params) {
+  GL_SERVICE_LOG("glGetTexParameteriv"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexParameterivFn(target, pname, params);
+}
+
+void DebugGLApi::glGetTexParameterivRobustANGLEFn(GLenum target,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLint* params) {
+  GL_SERVICE_LOG("glGetTexParameterivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetTexParameterivRobustANGLEFn(target, pname, bufSize, length,
+                                            params);
+}
+
+void DebugGLApi::glGetTransformFeedbackVaryingFn(GLuint program,
+                                                 GLuint index,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLsizei* size,
+                                                 GLenum* type,
+                                                 char* name) {
+  GL_SERVICE_LOG("glGetTransformFeedbackVarying"
+                 << "(" << program << ", " << index << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(size) << ", "
+                 << static_cast<const void*>(type) << ", "
+                 << static_cast<const void*>(name) << ")");
+  gl_api_->glGetTransformFeedbackVaryingFn(program, index, bufSize, length,
+                                           size, type, name);
+}
+
+void DebugGLApi::glGetTranslatedShaderSourceANGLEFn(GLuint shader,
+                                                    GLsizei bufsize,
+                                                    GLsizei* length,
+                                                    char* source) {
+  GL_SERVICE_LOG("glGetTranslatedShaderSourceANGLE"
+                 << "(" << shader << ", " << bufsize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(source) << ")");
+  gl_api_->glGetTranslatedShaderSourceANGLEFn(shader, bufsize, length, source);
+}
+
+GLuint DebugGLApi::glGetUniformBlockIndexFn(GLuint program,
+                                            const char* uniformBlockName) {
+  GL_SERVICE_LOG("glGetUniformBlockIndex"
+                 << "(" << program << ", " << uniformBlockName << ")");
+  GLuint result = gl_api_->glGetUniformBlockIndexFn(program, uniformBlockName);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glGetUniformfvFn(GLuint program,
+                                  GLint location,
+                                  GLfloat* params) {
+  GL_SERVICE_LOG("glGetUniformfv"
+                 << "(" << program << ", " << location << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetUniformfvFn(program, location, params);
+}
+
+void DebugGLApi::glGetUniformfvRobustANGLEFn(GLuint program,
+                                             GLint location,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLfloat* params) {
+  GL_SERVICE_LOG("glGetUniformfvRobustANGLE"
+                 << "(" << program << ", " << location << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetUniformfvRobustANGLEFn(program, location, bufSize, length,
+                                       params);
+}
+
+void DebugGLApi::glGetUniformIndicesFn(GLuint program,
+                                       GLsizei uniformCount,
+                                       const char* const* uniformNames,
+                                       GLuint* uniformIndices) {
+  GL_SERVICE_LOG("glGetUniformIndices"
+                 << "(" << program << ", " << uniformCount << ", "
+                 << static_cast<const void*>(uniformNames) << ", "
+                 << static_cast<const void*>(uniformIndices) << ")");
+  gl_api_->glGetUniformIndicesFn(program, uniformCount, uniformNames,
+                                 uniformIndices);
+}
+
+void DebugGLApi::glGetUniformivFn(GLuint program,
+                                  GLint location,
+                                  GLint* params) {
+  GL_SERVICE_LOG("glGetUniformiv"
+                 << "(" << program << ", " << location << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetUniformivFn(program, location, params);
+}
+
+void DebugGLApi::glGetUniformivRobustANGLEFn(GLuint program,
+                                             GLint location,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLint* params) {
+  GL_SERVICE_LOG("glGetUniformivRobustANGLE"
+                 << "(" << program << ", " << location << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetUniformivRobustANGLEFn(program, location, bufSize, length,
+                                       params);
+}
+
+GLint DebugGLApi::glGetUniformLocationFn(GLuint program, const char* name) {
+  GL_SERVICE_LOG("glGetUniformLocation"
+                 << "(" << program << ", " << name << ")");
+  GLint result = gl_api_->glGetUniformLocationFn(program, name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glGetUniformuivFn(GLuint program,
+                                   GLint location,
+                                   GLuint* params) {
+  GL_SERVICE_LOG("glGetUniformuiv"
+                 << "(" << program << ", " << location << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetUniformuivFn(program, location, params);
+}
+
+void DebugGLApi::glGetUniformuivRobustANGLEFn(GLuint program,
+                                              GLint location,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              GLuint* params) {
+  GL_SERVICE_LOG("glGetUniformuivRobustANGLE"
+                 << "(" << program << ", " << location << ", " << bufSize
+                 << ", " << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glGetUniformuivRobustANGLEFn(program, location, bufSize, length,
+                                        params);
+}
+
+void DebugGLApi::glGetVertexAttribfvFn(GLuint index,
+                                       GLenum pname,
+                                       GLfloat* params) {
+  GL_SERVICE_LOG("glGetVertexAttribfv"
+                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetVertexAttribfvFn(index, pname, params);
+}
+
+void DebugGLApi::glGetVertexAttribfvRobustANGLEFn(GLuint index,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLfloat* params) {
+  GL_SERVICE_LOG("glGetVertexAttribfvRobustANGLE"
+                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetVertexAttribfvRobustANGLEFn(index, pname, bufSize, length,
+                                            params);
+}
+
+void DebugGLApi::glGetVertexAttribIivRobustANGLEFn(GLuint index,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei* length,
+                                                   GLint* params) {
+  GL_SERVICE_LOG("glGetVertexAttribIivRobustANGLE"
+                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetVertexAttribIivRobustANGLEFn(index, pname, bufSize, length,
+                                             params);
+}
+
+void DebugGLApi::glGetVertexAttribIuivRobustANGLEFn(GLuint index,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei* length,
+                                                    GLuint* params) {
+  GL_SERVICE_LOG("glGetVertexAttribIuivRobustANGLE"
+                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetVertexAttribIuivRobustANGLEFn(index, pname, bufSize, length,
+                                              params);
+}
+
+void DebugGLApi::glGetVertexAttribivFn(GLuint index,
+                                       GLenum pname,
+                                       GLint* params) {
+  GL_SERVICE_LOG("glGetVertexAttribiv"
+                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetVertexAttribivFn(index, pname, params);
+}
+
+void DebugGLApi::glGetVertexAttribivRobustANGLEFn(GLuint index,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLint* params) {
+  GL_SERVICE_LOG("glGetVertexAttribivRobustANGLE"
+                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glGetVertexAttribivRobustANGLEFn(index, pname, bufSize, length,
+                                            params);
+}
+
+void DebugGLApi::glGetVertexAttribPointervFn(GLuint index,
+                                             GLenum pname,
+                                             void** pointer) {
+  GL_SERVICE_LOG("glGetVertexAttribPointerv"
+                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << pointer << ")");
+  gl_api_->glGetVertexAttribPointervFn(index, pname, pointer);
+}
+
+void DebugGLApi::glGetVertexAttribPointervRobustANGLEFn(GLuint index,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei* length,
+                                                        void** pointer) {
+  GL_SERVICE_LOG("glGetVertexAttribPointervRobustANGLE"
+                 << "(" << index << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(length)
+                 << ", " << pointer << ")");
+  gl_api_->glGetVertexAttribPointervRobustANGLEFn(index, pname, bufSize, length,
+                                                  pointer);
+}
+
+void DebugGLApi::glHintFn(GLenum target, GLenum mode) {
+  GL_SERVICE_LOG("glHint"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(mode) << ")");
+  gl_api_->glHintFn(target, mode);
+}
+
+void DebugGLApi::glInsertEventMarkerEXTFn(GLsizei length, const char* marker) {
+  GL_SERVICE_LOG("glInsertEventMarkerEXT"
+                 << "(" << length << ", " << marker << ")");
+  gl_api_->glInsertEventMarkerEXTFn(length, marker);
+}
+
+void DebugGLApi::glInvalidateFramebufferFn(GLenum target,
+                                           GLsizei numAttachments,
+                                           const GLenum* attachments) {
+  GL_SERVICE_LOG("glInvalidateFramebuffer"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << numAttachments << ", "
+                 << static_cast<const void*>(attachments) << ")");
+  gl_api_->glInvalidateFramebufferFn(target, numAttachments, attachments);
+}
+
+void DebugGLApi::glInvalidateSubFramebufferFn(GLenum target,
+                                              GLsizei numAttachments,
+                                              const GLenum* attachments,
+                                              GLint x,
+                                              GLint y,
+                                              GLint width,
+                                              GLint height) {
+  GL_SERVICE_LOG("glInvalidateSubFramebuffer"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << numAttachments << ", "
+                 << static_cast<const void*>(attachments) << ", " << x << ", "
+                 << y << ", " << width << ", " << height << ")");
+  gl_api_->glInvalidateSubFramebufferFn(target, numAttachments, attachments, x,
+                                        y, width, height);
+}
+
+GLboolean DebugGLApi::glIsBufferFn(GLuint buffer) {
+  GL_SERVICE_LOG("glIsBuffer"
+                 << "(" << buffer << ")");
+  GLboolean result = gl_api_->glIsBufferFn(buffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsEnabledFn(GLenum cap) {
+  GL_SERVICE_LOG("glIsEnabled"
+                 << "(" << GLEnums::GetStringEnum(cap) << ")");
+  GLboolean result = gl_api_->glIsEnabledFn(cap);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsFenceAPPLEFn(GLuint fence) {
+  GL_SERVICE_LOG("glIsFenceAPPLE"
+                 << "(" << fence << ")");
+  GLboolean result = gl_api_->glIsFenceAPPLEFn(fence);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsFenceNVFn(GLuint fence) {
+  GL_SERVICE_LOG("glIsFenceNV"
+                 << "(" << fence << ")");
+  GLboolean result = gl_api_->glIsFenceNVFn(fence);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
+  GL_SERVICE_LOG("glIsFramebufferEXT"
+                 << "(" << framebuffer << ")");
+  GLboolean result = gl_api_->glIsFramebufferEXTFn(framebuffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsPathNVFn(GLuint path) {
+  GL_SERVICE_LOG("glIsPathNV"
+                 << "(" << path << ")");
+  GLboolean result = gl_api_->glIsPathNVFn(path);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsProgramFn(GLuint program) {
+  GL_SERVICE_LOG("glIsProgram"
+                 << "(" << program << ")");
+  GLboolean result = gl_api_->glIsProgramFn(program);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsQueryFn(GLuint query) {
+  GL_SERVICE_LOG("glIsQuery"
+                 << "(" << query << ")");
+  GLboolean result = gl_api_->glIsQueryFn(query);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsRenderbufferEXTFn(GLuint renderbuffer) {
+  GL_SERVICE_LOG("glIsRenderbufferEXT"
+                 << "(" << renderbuffer << ")");
+  GLboolean result = gl_api_->glIsRenderbufferEXTFn(renderbuffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsSamplerFn(GLuint sampler) {
+  GL_SERVICE_LOG("glIsSampler"
+                 << "(" << sampler << ")");
+  GLboolean result = gl_api_->glIsSamplerFn(sampler);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsShaderFn(GLuint shader) {
+  GL_SERVICE_LOG("glIsShader"
+                 << "(" << shader << ")");
+  GLboolean result = gl_api_->glIsShaderFn(shader);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsSyncFn(GLsync sync) {
+  GL_SERVICE_LOG("glIsSync"
+                 << "(" << sync << ")");
+  GLboolean result = gl_api_->glIsSyncFn(sync);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsTextureFn(GLuint texture) {
+  GL_SERVICE_LOG("glIsTexture"
+                 << "(" << texture << ")");
+  GLboolean result = gl_api_->glIsTextureFn(texture);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsTransformFeedbackFn(GLuint id) {
+  GL_SERVICE_LOG("glIsTransformFeedback"
+                 << "(" << id << ")");
+  GLboolean result = gl_api_->glIsTransformFeedbackFn(id);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glIsVertexArrayOESFn(GLuint array) {
+  GL_SERVICE_LOG("glIsVertexArrayOES"
+                 << "(" << array << ")");
+  GLboolean result = gl_api_->glIsVertexArrayOESFn(array);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glLineWidthFn(GLfloat width) {
+  GL_SERVICE_LOG("glLineWidth"
+                 << "(" << width << ")");
+  gl_api_->glLineWidthFn(width);
+}
+
+void DebugGLApi::glLinkProgramFn(GLuint program) {
+  GL_SERVICE_LOG("glLinkProgram"
+                 << "(" << program << ")");
+  gl_api_->glLinkProgramFn(program);
+}
+
+void* DebugGLApi::glMapBufferFn(GLenum target, GLenum access) {
+  GL_SERVICE_LOG("glMapBuffer"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(access) << ")");
+  void* result = gl_api_->glMapBufferFn(target, access);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void* DebugGLApi::glMapBufferRangeFn(GLenum target,
+                                     GLintptr offset,
+                                     GLsizeiptr length,
+                                     GLbitfield access) {
+  GL_SERVICE_LOG("glMapBufferRange"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << offset
+                 << ", " << length << ", " << access << ")");
+  void* result = gl_api_->glMapBufferRangeFn(target, offset, length, access);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
+  GL_SERVICE_LOG("glMatrixLoadfEXT"
+                 << "(" << GLEnums::GetStringEnum(matrixMode) << ", "
+                 << static_cast<const void*>(m) << ")");
+  gl_api_->glMatrixLoadfEXTFn(matrixMode, m);
+}
+
+void DebugGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
+  GL_SERVICE_LOG("glMatrixLoadIdentityEXT"
+                 << "(" << GLEnums::GetStringEnum(matrixMode) << ")");
+  gl_api_->glMatrixLoadIdentityEXTFn(matrixMode);
+}
+
+void DebugGLApi::glMemoryBarrierEXTFn(GLbitfield barriers) {
+  GL_SERVICE_LOG("glMemoryBarrierEXT"
+                 << "(" << barriers << ")");
+  gl_api_->glMemoryBarrierEXTFn(barriers);
+}
+
+void DebugGLApi::glObjectLabelFn(GLenum identifier,
+                                 GLuint name,
+                                 GLsizei length,
+                                 const char* label) {
+  GL_SERVICE_LOG("glObjectLabel"
+                 << "(" << GLEnums::GetStringEnum(identifier) << ", " << name
+                 << ", " << length << ", " << label << ")");
+  gl_api_->glObjectLabelFn(identifier, name, length, label);
+}
+
+void DebugGLApi::glObjectPtrLabelFn(void* ptr,
+                                    GLsizei length,
+                                    const char* label) {
+  GL_SERVICE_LOG("glObjectPtrLabel"
+                 << "(" << static_cast<const void*>(ptr) << ", " << length
+                 << ", " << label << ")");
+  gl_api_->glObjectPtrLabelFn(ptr, length, label);
+}
+
+void DebugGLApi::glPathCommandsNVFn(GLuint path,
+                                    GLsizei numCommands,
+                                    const GLubyte* commands,
+                                    GLsizei numCoords,
+                                    GLenum coordType,
+                                    const GLvoid* coords) {
+  GL_SERVICE_LOG("glPathCommandsNV"
+                 << "(" << path << ", " << numCommands << ", "
+                 << static_cast<const void*>(commands) << ", " << numCoords
+                 << ", " << GLEnums::GetStringEnum(coordType) << ", "
+                 << static_cast<const void*>(coords) << ")");
+  gl_api_->glPathCommandsNVFn(path, numCommands, commands, numCoords, coordType,
+                              coords);
+}
+
+void DebugGLApi::glPathParameterfNVFn(GLuint path,
+                                      GLenum pname,
+                                      GLfloat value) {
+  GL_SERVICE_LOG("glPathParameterfNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << value << ")");
+  gl_api_->glPathParameterfNVFn(path, pname, value);
+}
+
+void DebugGLApi::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
+  GL_SERVICE_LOG("glPathParameteriNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
+                 << value << ")");
+  gl_api_->glPathParameteriNVFn(path, pname, value);
+}
+
+void DebugGLApi::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
+  GL_SERVICE_LOG("glPathStencilFuncNV"
+                 << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
+                 << mask << ")");
+  gl_api_->glPathStencilFuncNVFn(func, ref, mask);
+}
+
+void DebugGLApi::glPauseTransformFeedbackFn(void) {
+  GL_SERVICE_LOG("glPauseTransformFeedback"
+                 << "("
+                 << ")");
+  gl_api_->glPauseTransformFeedbackFn();
+}
+
+void DebugGLApi::glPixelStoreiFn(GLenum pname, GLint param) {
+  GL_SERVICE_LOG("glPixelStorei"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << param
+                 << ")");
+  gl_api_->glPixelStoreiFn(pname, param);
+}
+
+void DebugGLApi::glPointParameteriFn(GLenum pname, GLint param) {
+  GL_SERVICE_LOG("glPointParameteri"
+                 << "(" << GLEnums::GetStringEnum(pname) << ", " << param
+                 << ")");
+  gl_api_->glPointParameteriFn(pname, param);
+}
+
+void DebugGLApi::glPolygonOffsetFn(GLfloat factor, GLfloat units) {
+  GL_SERVICE_LOG("glPolygonOffset"
+                 << "(" << factor << ", " << units << ")");
+  gl_api_->glPolygonOffsetFn(factor, units);
+}
+
+void DebugGLApi::glPopDebugGroupFn() {
+  GL_SERVICE_LOG("glPopDebugGroup"
+                 << "("
+                 << ")");
+  gl_api_->glPopDebugGroupFn();
+}
+
+void DebugGLApi::glPopGroupMarkerEXTFn(void) {
+  GL_SERVICE_LOG("glPopGroupMarkerEXT"
+                 << "("
+                 << ")");
+  gl_api_->glPopGroupMarkerEXTFn();
+}
+
+void DebugGLApi::glPrimitiveRestartIndexFn(GLuint index) {
+  GL_SERVICE_LOG("glPrimitiveRestartIndex"
+                 << "(" << index << ")");
+  gl_api_->glPrimitiveRestartIndexFn(index);
+}
+
+void DebugGLApi::glProgramBinaryFn(GLuint program,
+                                   GLenum binaryFormat,
+                                   const GLvoid* binary,
+                                   GLsizei length) {
+  GL_SERVICE_LOG("glProgramBinary"
+                 << "(" << program << ", "
+                 << GLEnums::GetStringEnum(binaryFormat) << ", "
+                 << static_cast<const void*>(binary) << ", " << length << ")");
+  gl_api_->glProgramBinaryFn(program, binaryFormat, binary, length);
+}
+
+void DebugGLApi::glProgramParameteriFn(GLuint program,
+                                       GLenum pname,
+                                       GLint value) {
+  GL_SERVICE_LOG("glProgramParameteri"
+                 << "(" << program << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << value << ")");
+  gl_api_->glProgramParameteriFn(program, pname, value);
+}
+
+void DebugGLApi::glProgramPathFragmentInputGenNVFn(GLuint program,
+                                                   GLint location,
+                                                   GLenum genMode,
+                                                   GLint components,
+                                                   const GLfloat* coeffs) {
+  GL_SERVICE_LOG("glProgramPathFragmentInputGenNV"
+                 << "(" << program << ", " << location << ", "
+                 << GLEnums::GetStringEnum(genMode) << ", " << components
+                 << ", " << static_cast<const void*>(coeffs) << ")");
+  gl_api_->glProgramPathFragmentInputGenNVFn(program, location, genMode,
+                                             components, coeffs);
+}
+
+void DebugGLApi::glPushDebugGroupFn(GLenum source,
+                                    GLuint id,
+                                    GLsizei length,
+                                    const char* message) {
+  GL_SERVICE_LOG("glPushDebugGroup"
+                 << "(" << GLEnums::GetStringEnum(source) << ", " << id << ", "
+                 << length << ", " << message << ")");
+  gl_api_->glPushDebugGroupFn(source, id, length, message);
+}
+
+void DebugGLApi::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) {
+  GL_SERVICE_LOG("glPushGroupMarkerEXT"
+                 << "(" << length << ", " << marker << ")");
+  gl_api_->glPushGroupMarkerEXTFn(length, marker);
+}
+
+void DebugGLApi::glQueryCounterFn(GLuint id, GLenum target) {
+  GL_SERVICE_LOG("glQueryCounter"
+                 << "(" << id << ", " << GLEnums::GetStringEnum(target) << ")");
+  gl_api_->glQueryCounterFn(id, target);
+}
+
+void DebugGLApi::glReadBufferFn(GLenum src) {
+  GL_SERVICE_LOG("glReadBuffer"
+                 << "(" << GLEnums::GetStringEnum(src) << ")");
+  gl_api_->glReadBufferFn(src);
+}
+
+void DebugGLApi::glReadnPixelsRobustANGLEFn(GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            GLsizei bufSize,
+                                            GLsizei* length,
+                                            void* data) {
+  GL_SERVICE_LOG("glReadnPixelsRobustANGLE"
+                 << "(" << x << ", " << y << ", " << width << ", " << height
+                 << ", " << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(data) << ")");
+  gl_api_->glReadnPixelsRobustANGLEFn(x, y, width, height, format, type,
+                                      bufSize, length, data);
+}
+
+void DebugGLApi::glReadPixelsFn(GLint x,
+                                GLint y,
+                                GLsizei width,
+                                GLsizei height,
+                                GLenum format,
+                                GLenum type,
+                                void* pixels) {
+  GL_SERVICE_LOG("glReadPixels"
+                 << "(" << x << ", " << y << ", " << width << ", " << height
+                 << ", " << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glReadPixelsFn(x, y, width, height, format, type, pixels);
+}
+
+void DebugGLApi::glReadPixelsRobustANGLEFn(GLint x,
+                                           GLint y,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLenum format,
+                                           GLenum type,
+                                           GLsizei bufSize,
+                                           GLsizei* length,
+                                           void* pixels) {
+  GL_SERVICE_LOG("glReadPixelsRobustANGLE"
+                 << "(" << x << ", " << y << ", " << width << ", " << height
+                 << ", " << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
+                 << static_cast<const void*>(length) << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glReadPixelsRobustANGLEFn(x, y, width, height, format, type, bufSize,
+                                     length, pixels);
+}
+
+void DebugGLApi::glReleaseShaderCompilerFn(void) {
+  GL_SERVICE_LOG("glReleaseShaderCompiler"
+                 << "("
+                 << ")");
+  gl_api_->glReleaseShaderCompilerFn();
+}
+
+void DebugGLApi::glRenderbufferStorageEXTFn(GLenum target,
+                                            GLenum internalformat,
+                                            GLsizei width,
+                                            GLsizei height) {
+  GL_SERVICE_LOG("glRenderbufferStorageEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(internalformat) << ", " << width
+                 << ", " << height << ")");
+  gl_api_->glRenderbufferStorageEXTFn(target, internalformat, width, height);
+}
+
+void DebugGLApi::glRenderbufferStorageMultisampleFn(GLenum target,
+                                                    GLsizei samples,
+                                                    GLenum internalformat,
+                                                    GLsizei width,
+                                                    GLsizei height) {
+  GL_SERVICE_LOG("glRenderbufferStorageMultisample"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << samples
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
+                 << width << ", " << height << ")");
+  gl_api_->glRenderbufferStorageMultisampleFn(target, samples, internalformat,
+                                              width, height);
+}
+
+void DebugGLApi::glRenderbufferStorageMultisampleANGLEFn(GLenum target,
+                                                         GLsizei samples,
+                                                         GLenum internalformat,
+                                                         GLsizei width,
+                                                         GLsizei height) {
+  GL_SERVICE_LOG("glRenderbufferStorageMultisampleANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << samples
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
+                 << width << ", " << height << ")");
+  gl_api_->glRenderbufferStorageMultisampleANGLEFn(
+      target, samples, internalformat, width, height);
+}
+
+void DebugGLApi::glRenderbufferStorageMultisampleEXTFn(GLenum target,
+                                                       GLsizei samples,
+                                                       GLenum internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height) {
+  GL_SERVICE_LOG("glRenderbufferStorageMultisampleEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << samples
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
+                 << width << ", " << height << ")");
+  gl_api_->glRenderbufferStorageMultisampleEXTFn(target, samples,
+                                                 internalformat, width, height);
+}
+
+void DebugGLApi::glRenderbufferStorageMultisampleIMGFn(GLenum target,
+                                                       GLsizei samples,
+                                                       GLenum internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height) {
+  GL_SERVICE_LOG("glRenderbufferStorageMultisampleIMG"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << samples
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
+                 << width << ", " << height << ")");
+  gl_api_->glRenderbufferStorageMultisampleIMGFn(target, samples,
+                                                 internalformat, width, height);
+}
+
+void DebugGLApi::glResumeTransformFeedbackFn(void) {
+  GL_SERVICE_LOG("glResumeTransformFeedback"
+                 << "("
+                 << ")");
+  gl_api_->glResumeTransformFeedbackFn();
+}
+
+void DebugGLApi::glSampleCoverageFn(GLclampf value, GLboolean invert) {
+  GL_SERVICE_LOG("glSampleCoverage"
+                 << "(" << value << ", " << GLEnums::GetStringBool(invert)
+                 << ")");
+  gl_api_->glSampleCoverageFn(value, invert);
+}
+
+void DebugGLApi::glSamplerParameterfFn(GLuint sampler,
+                                       GLenum pname,
+                                       GLfloat param) {
+  GL_SERVICE_LOG("glSamplerParameterf"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << param << ")");
+  gl_api_->glSamplerParameterfFn(sampler, pname, param);
+}
+
+void DebugGLApi::glSamplerParameterfvFn(GLuint sampler,
+                                        GLenum pname,
+                                        const GLfloat* params) {
+  GL_SERVICE_LOG("glSamplerParameterfv"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glSamplerParameterfvFn(sampler, pname, params);
+}
+
+void DebugGLApi::glSamplerParameterfvRobustANGLEFn(GLuint sampler,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   const GLfloat* param) {
+  GL_SERVICE_LOG("glSamplerParameterfvRobustANGLE"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(param)
+                 << ")");
+  gl_api_->glSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void DebugGLApi::glSamplerParameteriFn(GLuint sampler,
+                                       GLenum pname,
+                                       GLint param) {
+  GL_SERVICE_LOG("glSamplerParameteri"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << param << ")");
+  gl_api_->glSamplerParameteriFn(sampler, pname, param);
+}
+
+void DebugGLApi::glSamplerParameterIivRobustANGLEFn(GLuint sampler,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    const GLint* param) {
+  GL_SERVICE_LOG("glSamplerParameterIivRobustANGLE"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(param)
+                 << ")");
+  gl_api_->glSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void DebugGLApi::glSamplerParameterIuivRobustANGLEFn(GLuint sampler,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     const GLuint* param) {
+  GL_SERVICE_LOG("glSamplerParameterIuivRobustANGLE"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(param)
+                 << ")");
+  gl_api_->glSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void DebugGLApi::glSamplerParameterivFn(GLuint sampler,
+                                        GLenum pname,
+                                        const GLint* params) {
+  GL_SERVICE_LOG("glSamplerParameteriv"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << static_cast<const void*>(params) << ")");
+  gl_api_->glSamplerParameterivFn(sampler, pname, params);
+}
+
+void DebugGLApi::glSamplerParameterivRobustANGLEFn(GLuint sampler,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   const GLint* param) {
+  GL_SERVICE_LOG("glSamplerParameterivRobustANGLE"
+                 << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
+                 << ", " << bufSize << ", " << static_cast<const void*>(param)
+                 << ")");
+  gl_api_->glSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void DebugGLApi::glScissorFn(GLint x, GLint y, GLsizei width, GLsizei height) {
+  GL_SERVICE_LOG("glScissor"
+                 << "(" << x << ", " << y << ", " << width << ", " << height
+                 << ")");
+  gl_api_->glScissorFn(x, y, width, height);
+}
+
+void DebugGLApi::glSetFenceAPPLEFn(GLuint fence) {
+  GL_SERVICE_LOG("glSetFenceAPPLE"
+                 << "(" << fence << ")");
+  gl_api_->glSetFenceAPPLEFn(fence);
+}
+
+void DebugGLApi::glSetFenceNVFn(GLuint fence, GLenum condition) {
+  GL_SERVICE_LOG("glSetFenceNV"
+                 << "(" << fence << ", " << GLEnums::GetStringEnum(condition)
+                 << ")");
+  gl_api_->glSetFenceNVFn(fence, condition);
+}
+
+void DebugGLApi::glShaderBinaryFn(GLsizei n,
+                                  const GLuint* shaders,
+                                  GLenum binaryformat,
+                                  const void* binary,
+                                  GLsizei length) {
+  GL_SERVICE_LOG("glShaderBinary"
+                 << "(" << n << ", " << static_cast<const void*>(shaders)
+                 << ", " << GLEnums::GetStringEnum(binaryformat) << ", "
+                 << static_cast<const void*>(binary) << ", " << length << ")");
+  gl_api_->glShaderBinaryFn(n, shaders, binaryformat, binary, length);
+}
+
+void DebugGLApi::glShaderSourceFn(GLuint shader,
+                                  GLsizei count,
+                                  const char* const* str,
+                                  const GLint* length) {
+  GL_SERVICE_LOG("glShaderSource"
+                 << "(" << shader << ", " << count << ", "
+                 << static_cast<const void*>(str) << ", "
+                 << static_cast<const void*>(length) << ")");
+  gl_api_->glShaderSourceFn(shader, count, str, length);
+
+  GL_SERVICE_LOG_CODE_BLOCK({
+    for (GLsizei ii = 0; ii < count; ++ii) {
+      if (str[ii]) {
+        if (length && length[ii] >= 0) {
+          std::string source(str[ii], length[ii]);
+          GL_SERVICE_LOG("  " << ii << ": ---\n" << source << "\n---");
+        } else {
+          GL_SERVICE_LOG("  " << ii << ": ---\n" << str[ii] << "\n---");
+        }
+      } else {
+        GL_SERVICE_LOG("  " << ii << ": NULL");
+      }
+    }
+  });
+}
+
+void DebugGLApi::glStencilFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GL_SERVICE_LOG("glStencilFillPathInstancedNV"
+                 << "(" << numPaths << ", "
+                 << GLEnums::GetStringEnum(pathNameType) << ", "
+                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
+                 << GLEnums::GetStringEnum(fillMode) << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(transformType) << ", "
+                 << static_cast<const void*>(transformValues) << ")");
+  gl_api_->glStencilFillPathInstancedNVFn(numPaths, pathNameType, paths,
+                                          pathBase, fillMode, mask,
+                                          transformType, transformValues);
+}
+
+void DebugGLApi::glStencilFillPathNVFn(GLuint path,
+                                       GLenum fillMode,
+                                       GLuint mask) {
+  GL_SERVICE_LOG("glStencilFillPathNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
+                 << ", " << mask << ")");
+  gl_api_->glStencilFillPathNVFn(path, fillMode, mask);
+}
+
+void DebugGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
+  GL_SERVICE_LOG("glStencilFunc"
+                 << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
+                 << mask << ")");
+  gl_api_->glStencilFuncFn(func, ref, mask);
+}
+
+void DebugGLApi::glStencilFuncSeparateFn(GLenum face,
+                                         GLenum func,
+                                         GLint ref,
+                                         GLuint mask) {
+  GL_SERVICE_LOG("glStencilFuncSeparate"
+                 << "(" << GLEnums::GetStringEnum(face) << ", "
+                 << GLEnums::GetStringEnum(func) << ", " << ref << ", " << mask
+                 << ")");
+  gl_api_->glStencilFuncSeparateFn(face, func, ref, mask);
+}
+
+void DebugGLApi::glStencilMaskFn(GLuint mask) {
+  GL_SERVICE_LOG("glStencilMask"
+                 << "(" << mask << ")");
+  gl_api_->glStencilMaskFn(mask);
+}
+
+void DebugGLApi::glStencilMaskSeparateFn(GLenum face, GLuint mask) {
+  GL_SERVICE_LOG("glStencilMaskSeparate"
+                 << "(" << GLEnums::GetStringEnum(face) << ", " << mask << ")");
+  gl_api_->glStencilMaskSeparateFn(face, mask);
+}
+
+void DebugGLApi::glStencilOpFn(GLenum fail, GLenum zfail, GLenum zpass) {
+  GL_SERVICE_LOG("glStencilOp"
+                 << "(" << GLEnums::GetStringEnum(fail) << ", "
+                 << GLEnums::GetStringEnum(zfail) << ", "
+                 << GLEnums::GetStringEnum(zpass) << ")");
+  gl_api_->glStencilOpFn(fail, zfail, zpass);
+}
+
+void DebugGLApi::glStencilOpSeparateFn(GLenum face,
+                                       GLenum fail,
+                                       GLenum zfail,
+                                       GLenum zpass) {
+  GL_SERVICE_LOG("glStencilOpSeparate"
+                 << "(" << GLEnums::GetStringEnum(face) << ", "
+                 << GLEnums::GetStringEnum(fail) << ", "
+                 << GLEnums::GetStringEnum(zfail) << ", "
+                 << GLEnums::GetStringEnum(zpass) << ")");
+  gl_api_->glStencilOpSeparateFn(face, fail, zfail, zpass);
+}
+
+void DebugGLApi::glStencilStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GL_SERVICE_LOG(
+      "glStencilStrokePathInstancedNV"
+      << "(" << numPaths << ", " << GLEnums::GetStringEnum(pathNameType) << ", "
+      << static_cast<const void*>(paths) << ", " << pathBase << ", " << ref
+      << ", " << mask << ", " << GLEnums::GetStringEnum(transformType) << ", "
+      << static_cast<const void*>(transformValues) << ")");
+  gl_api_->glStencilStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+                                            pathBase, ref, mask, transformType,
+                                            transformValues);
+}
+
+void DebugGLApi::glStencilStrokePathNVFn(GLuint path,
+                                         GLint reference,
+                                         GLuint mask) {
+  GL_SERVICE_LOG("glStencilStrokePathNV"
+                 << "(" << path << ", " << reference << ", " << mask << ")");
+  gl_api_->glStencilStrokePathNVFn(path, reference, mask);
+}
+
+void DebugGLApi::glStencilThenCoverFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GL_SERVICE_LOG("glStencilThenCoverFillPathInstancedNV"
+                 << "(" << numPaths << ", "
+                 << GLEnums::GetStringEnum(pathNameType) << ", "
+                 << static_cast<const void*>(paths) << ", " << pathBase << ", "
+                 << GLEnums::GetStringEnum(fillMode) << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(coverMode) << ", "
+                 << GLEnums::GetStringEnum(transformType) << ", "
+                 << static_cast<const void*>(transformValues) << ")");
+  gl_api_->glStencilThenCoverFillPathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+      transformType, transformValues);
+}
+
+void DebugGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
+                                                GLenum fillMode,
+                                                GLuint mask,
+                                                GLenum coverMode) {
+  GL_SERVICE_LOG("glStencilThenCoverFillPathNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
+                 << ", " << mask << ", " << GLEnums::GetStringEnum(coverMode)
+                 << ")");
+  gl_api_->glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
+}
+
+void DebugGLApi::glStencilThenCoverStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  GL_SERVICE_LOG(
+      "glStencilThenCoverStrokePathInstancedNV"
+      << "(" << numPaths << ", " << GLEnums::GetStringEnum(pathNameType) << ", "
+      << static_cast<const void*>(paths) << ", " << pathBase << ", " << ref
+      << ", " << mask << ", " << GLEnums::GetStringEnum(coverMode) << ", "
+      << GLEnums::GetStringEnum(transformType) << ", "
+      << static_cast<const void*>(transformValues) << ")");
+  gl_api_->glStencilThenCoverStrokePathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
+      transformType, transformValues);
+}
+
+void DebugGLApi::glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                  GLint reference,
+                                                  GLuint mask,
+                                                  GLenum coverMode) {
+  GL_SERVICE_LOG("glStencilThenCoverStrokePathNV"
+                 << "(" << path << ", " << reference << ", " << mask << ", "
+                 << GLEnums::GetStringEnum(coverMode) << ")");
+  gl_api_->glStencilThenCoverStrokePathNVFn(path, reference, mask, coverMode);
+}
+
+GLboolean DebugGLApi::glTestFenceAPPLEFn(GLuint fence) {
+  GL_SERVICE_LOG("glTestFenceAPPLE"
+                 << "(" << fence << ")");
+  GLboolean result = gl_api_->glTestFenceAPPLEFn(fence);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugGLApi::glTestFenceNVFn(GLuint fence) {
+  GL_SERVICE_LOG("glTestFenceNV"
+                 << "(" << fence << ")");
+  GLboolean result = gl_api_->glTestFenceNVFn(fence);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glTexImage2DFn(GLenum target,
+                                GLint level,
+                                GLint internalformat,
+                                GLsizei width,
+                                GLsizei height,
+                                GLint border,
+                                GLenum format,
+                                GLenum type,
+                                const void* pixels) {
+  GL_SERVICE_LOG("glTexImage2D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << internalformat << ", " << width << ", " << height
+                 << ", " << border << ", " << GLEnums::GetStringEnum(format)
+                 << ", " << GLEnums::GetStringEnum(type) << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glTexImage2DFn(target, level, internalformat, width, height, border,
+                          format, type, pixels);
+}
+
+void DebugGLApi::glTexImage2DRobustANGLEFn(GLenum target,
+                                           GLint level,
+                                           GLint internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLint border,
+                                           GLenum format,
+                                           GLenum type,
+                                           GLsizei bufSize,
+                                           const void* pixels) {
+  GL_SERVICE_LOG("glTexImage2DRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << internalformat << ", " << width << ", " << height
+                 << ", " << border << ", " << GLEnums::GetStringEnum(format)
+                 << ", " << GLEnums::GetStringEnum(type) << ", " << bufSize
+                 << ", " << static_cast<const void*>(pixels) << ")");
+  gl_api_->glTexImage2DRobustANGLEFn(target, level, internalformat, width,
+                                     height, border, format, type, bufSize,
+                                     pixels);
+}
+
+void DebugGLApi::glTexImage3DFn(GLenum target,
+                                GLint level,
+                                GLint internalformat,
+                                GLsizei width,
+                                GLsizei height,
+                                GLsizei depth,
+                                GLint border,
+                                GLenum format,
+                                GLenum type,
+                                const void* pixels) {
+  GL_SERVICE_LOG("glTexImage3D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << internalformat << ", " << width << ", " << height
+                 << ", " << depth << ", " << border << ", "
+                 << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glTexImage3DFn(target, level, internalformat, width, height, depth,
+                          border, format, type, pixels);
+}
+
+void DebugGLApi::glTexImage3DRobustANGLEFn(GLenum target,
+                                           GLint level,
+                                           GLint internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth,
+                                           GLint border,
+                                           GLenum format,
+                                           GLenum type,
+                                           GLsizei bufSize,
+                                           const void* pixels) {
+  GL_SERVICE_LOG("glTexImage3DRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << internalformat << ", " << width << ", " << height
+                 << ", " << depth << ", " << border << ", "
+                 << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glTexImage3DRobustANGLEFn(target, level, internalformat, width,
+                                     height, depth, border, format, type,
+                                     bufSize, pixels);
+}
+
+void DebugGLApi::glTexParameterfFn(GLenum target, GLenum pname, GLfloat param) {
+  GL_SERVICE_LOG("glTexParameterf"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << param << ")");
+  gl_api_->glTexParameterfFn(target, pname, param);
+}
+
+void DebugGLApi::glTexParameterfvFn(GLenum target,
+                                    GLenum pname,
+                                    const GLfloat* params) {
+  GL_SERVICE_LOG("glTexParameterfv"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glTexParameterfvFn(target, pname, params);
+}
+
+void DebugGLApi::glTexParameterfvRobustANGLEFn(GLenum target,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               const GLfloat* params) {
+  GL_SERVICE_LOG("glTexParameterfvRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glTexParameterfvRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void DebugGLApi::glTexParameteriFn(GLenum target, GLenum pname, GLint param) {
+  GL_SERVICE_LOG("glTexParameteri"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << param << ")");
+  gl_api_->glTexParameteriFn(target, pname, param);
+}
+
+void DebugGLApi::glTexParameterIivRobustANGLEFn(GLenum target,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                const GLint* params) {
+  GL_SERVICE_LOG("glTexParameterIivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glTexParameterIivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void DebugGLApi::glTexParameterIuivRobustANGLEFn(GLenum target,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 const GLuint* params) {
+  GL_SERVICE_LOG("glTexParameterIuivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glTexParameterIuivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void DebugGLApi::glTexParameterivFn(GLenum target,
+                                    GLenum pname,
+                                    const GLint* params) {
+  GL_SERVICE_LOG("glTexParameteriv"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glTexParameterivFn(target, pname, params);
+}
+
+void DebugGLApi::glTexParameterivRobustANGLEFn(GLenum target,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               const GLint* params) {
+  GL_SERVICE_LOG("glTexParameterivRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", "
+                 << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
+                 << static_cast<const void*>(params) << ")");
+  gl_api_->glTexParameterivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void DebugGLApi::glTexStorage2DEXTFn(GLenum target,
+                                     GLsizei levels,
+                                     GLenum internalformat,
+                                     GLsizei width,
+                                     GLsizei height) {
+  GL_SERVICE_LOG("glTexStorage2DEXT"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << levels
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
+                 << width << ", " << height << ")");
+  gl_api_->glTexStorage2DEXTFn(target, levels, internalformat, width, height);
+}
+
+void DebugGLApi::glTexStorage3DFn(GLenum target,
+                                  GLsizei levels,
+                                  GLenum internalformat,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLsizei depth) {
+  GL_SERVICE_LOG("glTexStorage3D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << levels
+                 << ", " << GLEnums::GetStringEnum(internalformat) << ", "
+                 << width << ", " << height << ", " << depth << ")");
+  gl_api_->glTexStorage3DFn(target, levels, internalformat, width, height,
+                            depth);
+}
+
+void DebugGLApi::glTexSubImage2DFn(GLenum target,
+                                   GLint level,
+                                   GLint xoffset,
+                                   GLint yoffset,
+                                   GLsizei width,
+                                   GLsizei height,
+                                   GLenum format,
+                                   GLenum type,
+                                   const void* pixels) {
+  GL_SERVICE_LOG("glTexSubImage2D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << xoffset << ", " << yoffset << ", " << width << ", "
+                 << height << ", " << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glTexSubImage2DFn(target, level, xoffset, yoffset, width, height,
+                             format, type, pixels);
+}
+
+void DebugGLApi::glTexSubImage2DRobustANGLEFn(GLenum target,
+                                              GLint level,
+                                              GLint xoffset,
+                                              GLint yoffset,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLenum format,
+                                              GLenum type,
+                                              GLsizei bufSize,
+                                              const void* pixels) {
+  GL_SERVICE_LOG("glTexSubImage2DRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << xoffset << ", " << yoffset << ", " << width << ", "
+                 << height << ", " << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glTexSubImage2DRobustANGLEFn(target, level, xoffset, yoffset, width,
+                                        height, format, type, bufSize, pixels);
+}
+
+void DebugGLApi::glTexSubImage3DFn(GLenum target,
+                                   GLint level,
+                                   GLint xoffset,
+                                   GLint yoffset,
+                                   GLint zoffset,
+                                   GLsizei width,
+                                   GLsizei height,
+                                   GLsizei depth,
+                                   GLenum format,
+                                   GLenum type,
+                                   const void* pixels) {
+  GL_SERVICE_LOG("glTexSubImage3D"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << xoffset << ", " << yoffset << ", " << zoffset
+                 << ", " << width << ", " << height << ", " << depth << ", "
+                 << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, width,
+                             height, depth, format, type, pixels);
+}
+
+void DebugGLApi::glTexSubImage3DRobustANGLEFn(GLenum target,
+                                              GLint level,
+                                              GLint xoffset,
+                                              GLint yoffset,
+                                              GLint zoffset,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLsizei depth,
+                                              GLenum format,
+                                              GLenum type,
+                                              GLsizei bufSize,
+                                              const void* pixels) {
+  GL_SERVICE_LOG("glTexSubImage3DRobustANGLE"
+                 << "(" << GLEnums::GetStringEnum(target) << ", " << level
+                 << ", " << xoffset << ", " << yoffset << ", " << zoffset
+                 << ", " << width << ", " << height << ", " << depth << ", "
+                 << GLEnums::GetStringEnum(format) << ", "
+                 << GLEnums::GetStringEnum(type) << ", " << bufSize << ", "
+                 << static_cast<const void*>(pixels) << ")");
+  gl_api_->glTexSubImage3DRobustANGLEFn(target, level, xoffset, yoffset,
+                                        zoffset, width, height, depth, format,
+                                        type, bufSize, pixels);
+}
+
+void DebugGLApi::glTransformFeedbackVaryingsFn(GLuint program,
+                                               GLsizei count,
+                                               const char* const* varyings,
+                                               GLenum bufferMode) {
+  GL_SERVICE_LOG("glTransformFeedbackVaryings"
+                 << "(" << program << ", " << count << ", "
+                 << static_cast<const void*>(varyings) << ", "
+                 << GLEnums::GetStringEnum(bufferMode) << ")");
+  gl_api_->glTransformFeedbackVaryingsFn(program, count, varyings, bufferMode);
+}
+
+void DebugGLApi::glUniform1fFn(GLint location, GLfloat x) {
+  GL_SERVICE_LOG("glUniform1f"
+                 << "(" << location << ", " << x << ")");
+  gl_api_->glUniform1fFn(location, x);
+}
+
+void DebugGLApi::glUniform1fvFn(GLint location,
+                                GLsizei count,
+                                const GLfloat* v) {
+  GL_SERVICE_LOG("glUniform1fv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform1fvFn(location, count, v);
+}
+
+void DebugGLApi::glUniform1iFn(GLint location, GLint x) {
+  GL_SERVICE_LOG("glUniform1i"
+                 << "(" << location << ", " << x << ")");
+  gl_api_->glUniform1iFn(location, x);
+}
+
+void DebugGLApi::glUniform1ivFn(GLint location, GLsizei count, const GLint* v) {
+  GL_SERVICE_LOG("glUniform1iv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform1ivFn(location, count, v);
+}
+
+void DebugGLApi::glUniform1uiFn(GLint location, GLuint v0) {
+  GL_SERVICE_LOG("glUniform1ui"
+                 << "(" << location << ", " << v0 << ")");
+  gl_api_->glUniform1uiFn(location, v0);
+}
+
+void DebugGLApi::glUniform1uivFn(GLint location,
+                                 GLsizei count,
+                                 const GLuint* v) {
+  GL_SERVICE_LOG("glUniform1uiv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform1uivFn(location, count, v);
+}
+
+void DebugGLApi::glUniform2fFn(GLint location, GLfloat x, GLfloat y) {
+  GL_SERVICE_LOG("glUniform2f"
+                 << "(" << location << ", " << x << ", " << y << ")");
+  gl_api_->glUniform2fFn(location, x, y);
+}
+
+void DebugGLApi::glUniform2fvFn(GLint location,
+                                GLsizei count,
+                                const GLfloat* v) {
+  GL_SERVICE_LOG("glUniform2fv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform2fvFn(location, count, v);
+}
+
+void DebugGLApi::glUniform2iFn(GLint location, GLint x, GLint y) {
+  GL_SERVICE_LOG("glUniform2i"
+                 << "(" << location << ", " << x << ", " << y << ")");
+  gl_api_->glUniform2iFn(location, x, y);
+}
+
+void DebugGLApi::glUniform2ivFn(GLint location, GLsizei count, const GLint* v) {
+  GL_SERVICE_LOG("glUniform2iv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform2ivFn(location, count, v);
+}
+
+void DebugGLApi::glUniform2uiFn(GLint location, GLuint v0, GLuint v1) {
+  GL_SERVICE_LOG("glUniform2ui"
+                 << "(" << location << ", " << v0 << ", " << v1 << ")");
+  gl_api_->glUniform2uiFn(location, v0, v1);
+}
+
+void DebugGLApi::glUniform2uivFn(GLint location,
+                                 GLsizei count,
+                                 const GLuint* v) {
+  GL_SERVICE_LOG("glUniform2uiv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform2uivFn(location, count, v);
+}
+
+void DebugGLApi::glUniform3fFn(GLint location,
+                               GLfloat x,
+                               GLfloat y,
+                               GLfloat z) {
+  GL_SERVICE_LOG("glUniform3f"
+                 << "(" << location << ", " << x << ", " << y << ", " << z
+                 << ")");
+  gl_api_->glUniform3fFn(location, x, y, z);
+}
+
+void DebugGLApi::glUniform3fvFn(GLint location,
+                                GLsizei count,
+                                const GLfloat* v) {
+  GL_SERVICE_LOG("glUniform3fv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform3fvFn(location, count, v);
+}
+
+void DebugGLApi::glUniform3iFn(GLint location, GLint x, GLint y, GLint z) {
+  GL_SERVICE_LOG("glUniform3i"
+                 << "(" << location << ", " << x << ", " << y << ", " << z
+                 << ")");
+  gl_api_->glUniform3iFn(location, x, y, z);
+}
+
+void DebugGLApi::glUniform3ivFn(GLint location, GLsizei count, const GLint* v) {
+  GL_SERVICE_LOG("glUniform3iv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform3ivFn(location, count, v);
+}
+
+void DebugGLApi::glUniform3uiFn(GLint location,
+                                GLuint v0,
+                                GLuint v1,
+                                GLuint v2) {
+  GL_SERVICE_LOG("glUniform3ui"
+                 << "(" << location << ", " << v0 << ", " << v1 << ", " << v2
+                 << ")");
+  gl_api_->glUniform3uiFn(location, v0, v1, v2);
+}
+
+void DebugGLApi::glUniform3uivFn(GLint location,
+                                 GLsizei count,
+                                 const GLuint* v) {
+  GL_SERVICE_LOG("glUniform3uiv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform3uivFn(location, count, v);
+}
+
+void DebugGLApi::glUniform4fFn(GLint location,
+                               GLfloat x,
+                               GLfloat y,
+                               GLfloat z,
+                               GLfloat w) {
+  GL_SERVICE_LOG("glUniform4f"
+                 << "(" << location << ", " << x << ", " << y << ", " << z
+                 << ", " << w << ")");
+  gl_api_->glUniform4fFn(location, x, y, z, w);
+}
+
+void DebugGLApi::glUniform4fvFn(GLint location,
+                                GLsizei count,
+                                const GLfloat* v) {
+  GL_SERVICE_LOG("glUniform4fv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform4fvFn(location, count, v);
+}
+
+void DebugGLApi::glUniform4iFn(GLint location,
+                               GLint x,
+                               GLint y,
+                               GLint z,
+                               GLint w) {
+  GL_SERVICE_LOG("glUniform4i"
+                 << "(" << location << ", " << x << ", " << y << ", " << z
+                 << ", " << w << ")");
+  gl_api_->glUniform4iFn(location, x, y, z, w);
+}
+
+void DebugGLApi::glUniform4ivFn(GLint location, GLsizei count, const GLint* v) {
+  GL_SERVICE_LOG("glUniform4iv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform4ivFn(location, count, v);
+}
+
+void DebugGLApi::glUniform4uiFn(GLint location,
+                                GLuint v0,
+                                GLuint v1,
+                                GLuint v2,
+                                GLuint v3) {
+  GL_SERVICE_LOG("glUniform4ui"
+                 << "(" << location << ", " << v0 << ", " << v1 << ", " << v2
+                 << ", " << v3 << ")");
+  gl_api_->glUniform4uiFn(location, v0, v1, v2, v3);
+}
+
+void DebugGLApi::glUniform4uivFn(GLint location,
+                                 GLsizei count,
+                                 const GLuint* v) {
+  GL_SERVICE_LOG("glUniform4uiv"
+                 << "(" << location << ", " << count << ", "
+                 << static_cast<const void*>(v) << ")");
+  gl_api_->glUniform4uivFn(location, count, v);
+}
+
+void DebugGLApi::glUniformBlockBindingFn(GLuint program,
+                                         GLuint uniformBlockIndex,
+                                         GLuint uniformBlockBinding) {
+  GL_SERVICE_LOG("glUniformBlockBinding"
+                 << "(" << program << ", " << uniformBlockIndex << ", "
+                 << uniformBlockBinding << ")");
+  gl_api_->glUniformBlockBindingFn(program, uniformBlockIndex,
+                                   uniformBlockBinding);
+}
+
+void DebugGLApi::glUniformMatrix2fvFn(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix2fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix2fvFn(location, count, transpose, value);
+}
+
+void DebugGLApi::glUniformMatrix2x3fvFn(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix2x3fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix2x3fvFn(location, count, transpose, value);
+}
+
+void DebugGLApi::glUniformMatrix2x4fvFn(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix2x4fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix2x4fvFn(location, count, transpose, value);
+}
+
+void DebugGLApi::glUniformMatrix3fvFn(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix3fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix3fvFn(location, count, transpose, value);
+}
+
+void DebugGLApi::glUniformMatrix3x2fvFn(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix3x2fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix3x2fvFn(location, count, transpose, value);
+}
+
+void DebugGLApi::glUniformMatrix3x4fvFn(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix3x4fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix3x4fvFn(location, count, transpose, value);
+}
+
+void DebugGLApi::glUniformMatrix4fvFn(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix4fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix4fvFn(location, count, transpose, value);
+}
+
+void DebugGLApi::glUniformMatrix4x2fvFn(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix4x2fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix4x2fvFn(location, count, transpose, value);
+}
+
+void DebugGLApi::glUniformMatrix4x3fvFn(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat* value) {
+  GL_SERVICE_LOG("glUniformMatrix4x3fv"
+                 << "(" << location << ", " << count << ", "
+                 << GLEnums::GetStringBool(transpose) << ", "
+                 << static_cast<const void*>(value) << ")");
+  gl_api_->glUniformMatrix4x3fvFn(location, count, transpose, value);
+}
+
+GLboolean DebugGLApi::glUnmapBufferFn(GLenum target) {
+  GL_SERVICE_LOG("glUnmapBuffer"
+                 << "(" << GLEnums::GetStringEnum(target) << ")");
+  GLboolean result = gl_api_->glUnmapBufferFn(target);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLApi::glUseProgramFn(GLuint program) {
+  GL_SERVICE_LOG("glUseProgram"
+                 << "(" << program << ")");
+  gl_api_->glUseProgramFn(program);
+}
+
+void DebugGLApi::glValidateProgramFn(GLuint program) {
+  GL_SERVICE_LOG("glValidateProgram"
+                 << "(" << program << ")");
+  gl_api_->glValidateProgramFn(program);
+}
+
+void DebugGLApi::glVertexAttrib1fFn(GLuint indx, GLfloat x) {
+  GL_SERVICE_LOG("glVertexAttrib1f"
+                 << "(" << indx << ", " << x << ")");
+  gl_api_->glVertexAttrib1fFn(indx, x);
+}
+
+void DebugGLApi::glVertexAttrib1fvFn(GLuint indx, const GLfloat* values) {
+  GL_SERVICE_LOG("glVertexAttrib1fv"
+                 << "(" << indx << ", " << static_cast<const void*>(values)
+                 << ")");
+  gl_api_->glVertexAttrib1fvFn(indx, values);
+}
+
+void DebugGLApi::glVertexAttrib2fFn(GLuint indx, GLfloat x, GLfloat y) {
+  GL_SERVICE_LOG("glVertexAttrib2f"
+                 << "(" << indx << ", " << x << ", " << y << ")");
+  gl_api_->glVertexAttrib2fFn(indx, x, y);
+}
+
+void DebugGLApi::glVertexAttrib2fvFn(GLuint indx, const GLfloat* values) {
+  GL_SERVICE_LOG("glVertexAttrib2fv"
+                 << "(" << indx << ", " << static_cast<const void*>(values)
+                 << ")");
+  gl_api_->glVertexAttrib2fvFn(indx, values);
+}
+
+void DebugGLApi::glVertexAttrib3fFn(GLuint indx,
+                                    GLfloat x,
+                                    GLfloat y,
+                                    GLfloat z) {
+  GL_SERVICE_LOG("glVertexAttrib3f"
+                 << "(" << indx << ", " << x << ", " << y << ", " << z << ")");
+  gl_api_->glVertexAttrib3fFn(indx, x, y, z);
+}
+
+void DebugGLApi::glVertexAttrib3fvFn(GLuint indx, const GLfloat* values) {
+  GL_SERVICE_LOG("glVertexAttrib3fv"
+                 << "(" << indx << ", " << static_cast<const void*>(values)
+                 << ")");
+  gl_api_->glVertexAttrib3fvFn(indx, values);
+}
+
+void DebugGLApi::glVertexAttrib4fFn(GLuint indx,
+                                    GLfloat x,
+                                    GLfloat y,
+                                    GLfloat z,
+                                    GLfloat w) {
+  GL_SERVICE_LOG("glVertexAttrib4f"
+                 << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
+                 << w << ")");
+  gl_api_->glVertexAttrib4fFn(indx, x, y, z, w);
+}
+
+void DebugGLApi::glVertexAttrib4fvFn(GLuint indx, const GLfloat* values) {
+  GL_SERVICE_LOG("glVertexAttrib4fv"
+                 << "(" << indx << ", " << static_cast<const void*>(values)
+                 << ")");
+  gl_api_->glVertexAttrib4fvFn(indx, values);
+}
+
+void DebugGLApi::glVertexAttribDivisorANGLEFn(GLuint index, GLuint divisor) {
+  GL_SERVICE_LOG("glVertexAttribDivisorANGLE"
+                 << "(" << index << ", " << divisor << ")");
+  gl_api_->glVertexAttribDivisorANGLEFn(index, divisor);
+}
+
+void DebugGLApi::glVertexAttribI4iFn(GLuint indx,
+                                     GLint x,
+                                     GLint y,
+                                     GLint z,
+                                     GLint w) {
+  GL_SERVICE_LOG("glVertexAttribI4i"
+                 << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
+                 << w << ")");
+  gl_api_->glVertexAttribI4iFn(indx, x, y, z, w);
+}
+
+void DebugGLApi::glVertexAttribI4ivFn(GLuint indx, const GLint* values) {
+  GL_SERVICE_LOG("glVertexAttribI4iv"
+                 << "(" << indx << ", " << static_cast<const void*>(values)
+                 << ")");
+  gl_api_->glVertexAttribI4ivFn(indx, values);
+}
+
+void DebugGLApi::glVertexAttribI4uiFn(GLuint indx,
+                                      GLuint x,
+                                      GLuint y,
+                                      GLuint z,
+                                      GLuint w) {
+  GL_SERVICE_LOG("glVertexAttribI4ui"
+                 << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
+                 << w << ")");
+  gl_api_->glVertexAttribI4uiFn(indx, x, y, z, w);
+}
+
+void DebugGLApi::glVertexAttribI4uivFn(GLuint indx, const GLuint* values) {
+  GL_SERVICE_LOG("glVertexAttribI4uiv"
+                 << "(" << indx << ", " << static_cast<const void*>(values)
+                 << ")");
+  gl_api_->glVertexAttribI4uivFn(indx, values);
+}
+
+void DebugGLApi::glVertexAttribIPointerFn(GLuint indx,
+                                          GLint size,
+                                          GLenum type,
+                                          GLsizei stride,
+                                          const void* ptr) {
+  GL_SERVICE_LOG("glVertexAttribIPointer"
+                 << "(" << indx << ", " << size << ", "
+                 << GLEnums::GetStringEnum(type) << ", " << stride << ", "
+                 << static_cast<const void*>(ptr) << ")");
+  gl_api_->glVertexAttribIPointerFn(indx, size, type, stride, ptr);
+}
+
+void DebugGLApi::glVertexAttribPointerFn(GLuint indx,
+                                         GLint size,
+                                         GLenum type,
+                                         GLboolean normalized,
+                                         GLsizei stride,
+                                         const void* ptr) {
+  GL_SERVICE_LOG("glVertexAttribPointer"
+                 << "(" << indx << ", " << size << ", "
+                 << GLEnums::GetStringEnum(type) << ", "
+                 << GLEnums::GetStringBool(normalized) << ", " << stride << ", "
+                 << static_cast<const void*>(ptr) << ")");
+  gl_api_->glVertexAttribPointerFn(indx, size, type, normalized, stride, ptr);
+}
+
+void DebugGLApi::glViewportFn(GLint x, GLint y, GLsizei width, GLsizei height) {
+  GL_SERVICE_LOG("glViewport"
+                 << "(" << x << ", " << y << ", " << width << ", " << height
+                 << ")");
+  gl_api_->glViewportFn(x, y, width, height);
+}
+
+GLenum DebugGLApi::glWaitSyncFn(GLsync sync,
+                                GLbitfield flags,
+                                GLuint64 timeout) {
+  GL_SERVICE_LOG("glWaitSync"
+                 << "(" << sync << ", " << flags << ", " << timeout << ")");
+  GLenum result = gl_api_->glWaitSyncFn(sync, flags, timeout);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 void NoContextGLApi::glActiveTextureFn(GLenum texture) {
   NOTREACHED() << "Trying to call glActiveTexture() without current GL context";
   LOG(ERROR) << "Trying to call glActiveTexture() without current GL context";
diff --git a/chromium/ui/gl/gl_bindings_autogen_glx.cc b/chromium/ui/gl/gl_bindings_autogen_glx.cc
index 9dd188b9c9f..ef9f9ef9152 100644
--- a/chromium/ui/gl/gl_bindings_autogen_glx.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_glx.cc
@@ -20,7 +20,6 @@
 
 namespace gl {
 
-static bool g_debugBindingsInitialized;
 DriverGLX g_driver_glx;
 
 void DriverGLX::InitializeStaticBindings() {
@@ -136,844 +135,57 @@ void DriverGLX::InitializeExtensionBindings() {
   ext.b_GLX_SGI_video_sync =
       extensions.find("GLX_SGI_video_sync ") != std::string::npos;
 
-  debug_fn.glXBindTexImageEXTFn = 0;
   if (ext.b_GLX_EXT_texture_from_pixmap) {
     fn.glXBindTexImageEXTFn = reinterpret_cast<glXBindTexImageEXTProc>(
         GetGLProcAddress("glXBindTexImageEXT"));
   }
 
-  debug_fn.glXCopySubBufferMESAFn = 0;
   if (ext.b_GLX_MESA_copy_sub_buffer) {
     fn.glXCopySubBufferMESAFn = reinterpret_cast<glXCopySubBufferMESAProc>(
         GetGLProcAddress("glXCopySubBufferMESA"));
   }
 
-  debug_fn.glXCreateContextAttribsARBFn = 0;
   if (ext.b_GLX_ARB_create_context) {
     fn.glXCreateContextAttribsARBFn =
         reinterpret_cast<glXCreateContextAttribsARBProc>(
             GetGLProcAddress("glXCreateContextAttribsARB"));
   }
 
-  debug_fn.glXGetFBConfigFromVisualSGIXFn = 0;
   if (ext.b_GLX_SGIX_fbconfig) {
     fn.glXGetFBConfigFromVisualSGIXFn =
         reinterpret_cast<glXGetFBConfigFromVisualSGIXProc>(
             GetGLProcAddress("glXGetFBConfigFromVisualSGIX"));
   }
 
-  debug_fn.glXGetMscRateOMLFn = 0;
   if (ext.b_GLX_OML_sync_control) {
     fn.glXGetMscRateOMLFn = reinterpret_cast<glXGetMscRateOMLProc>(
         GetGLProcAddress("glXGetMscRateOML"));
   }
 
-  debug_fn.glXGetSyncValuesOMLFn = 0;
   if (ext.b_GLX_OML_sync_control) {
     fn.glXGetSyncValuesOMLFn = reinterpret_cast<glXGetSyncValuesOMLProc>(
         GetGLProcAddress("glXGetSyncValuesOML"));
   }
 
-  debug_fn.glXReleaseTexImageEXTFn = 0;
   if (ext.b_GLX_EXT_texture_from_pixmap) {
     fn.glXReleaseTexImageEXTFn = reinterpret_cast<glXReleaseTexImageEXTProc>(
         GetGLProcAddress("glXReleaseTexImageEXT"));
   }
 
-  debug_fn.glXSwapIntervalEXTFn = 0;
   if (ext.b_GLX_EXT_swap_control) {
     fn.glXSwapIntervalEXTFn = reinterpret_cast<glXSwapIntervalEXTProc>(
         GetGLProcAddress("glXSwapIntervalEXT"));
   }
 
-  debug_fn.glXSwapIntervalMESAFn = 0;
   if (ext.b_GLX_MESA_swap_control) {
     fn.glXSwapIntervalMESAFn = reinterpret_cast<glXSwapIntervalMESAProc>(
         GetGLProcAddress("glXSwapIntervalMESA"));
   }
 
-  debug_fn.glXWaitVideoSyncSGIFn = 0;
   if (ext.b_GLX_SGI_video_sync) {
     fn.glXWaitVideoSyncSGIFn = reinterpret_cast<glXWaitVideoSyncSGIProc>(
         GetGLProcAddress("glXWaitVideoSyncSGI"));
   }
-
-  if (g_debugBindingsInitialized)
-    InitializeDebugBindings();
-}
-
-extern "C" {
-
-static void GL_BINDING_CALL Debug_glXBindTexImageEXT(Display* dpy,
-                                                     GLXDrawable drawable,
-                                                     int buffer,
-                                                     int* attribList) {
-  GL_SERVICE_LOG("glXBindTexImageEXT"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << buffer << ", "
-                 << static_cast<const void*>(attribList) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXBindTexImageEXTFn != nullptr);
-  g_driver_glx.debug_fn.glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
-}
-
-static GLXFBConfig* GL_BINDING_CALL
-Debug_glXChooseFBConfig(Display* dpy,
-                        int screen,
-                        const int* attribList,
-                        int* nitems) {
-  GL_SERVICE_LOG("glXChooseFBConfig"
-                 << "(" << static_cast<const void*>(dpy) << ", " << screen
-                 << ", " << static_cast<const void*>(attribList) << ", "
-                 << static_cast<const void*>(nitems) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXChooseFBConfigFn != nullptr);
-  GLXFBConfig* result = g_driver_glx.debug_fn.glXChooseFBConfigFn(
-      dpy, screen, attribList, nitems);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static XVisualInfo* GL_BINDING_CALL Debug_glXChooseVisual(Display* dpy,
-                                                          int screen,
-                                                          int* attribList) {
-  GL_SERVICE_LOG("glXChooseVisual"
-                 << "(" << static_cast<const void*>(dpy) << ", " << screen
-                 << ", " << static_cast<const void*>(attribList) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXChooseVisualFn != nullptr);
-  XVisualInfo* result =
-      g_driver_glx.debug_fn.glXChooseVisualFn(dpy, screen, attribList);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glXCopyContext(Display* dpy,
-                                                 GLXContext src,
-                                                 GLXContext dst,
-                                                 unsigned long mask) {
-  GL_SERVICE_LOG("glXCopyContext"
-                 << "(" << static_cast<const void*>(dpy) << ", " << src << ", "
-                 << dst << ", " << mask << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCopyContextFn != nullptr);
-  g_driver_glx.debug_fn.glXCopyContextFn(dpy, src, dst, mask);
-}
-
-static void GL_BINDING_CALL Debug_glXCopySubBufferMESA(Display* dpy,
-                                                       GLXDrawable drawable,
-                                                       int x,
-                                                       int y,
-                                                       int width,
-                                                       int height) {
-  GL_SERVICE_LOG("glXCopySubBufferMESA"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << x << ", " << y << ", " << width << ", " << height
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCopySubBufferMESAFn != nullptr);
-  g_driver_glx.debug_fn.glXCopySubBufferMESAFn(dpy, drawable, x, y, width,
-                                               height);
-}
-
-static GLXContext GL_BINDING_CALL Debug_glXCreateContext(Display* dpy,
-                                                         XVisualInfo* vis,
-                                                         GLXContext shareList,
-                                                         int direct) {
-  GL_SERVICE_LOG("glXCreateContext"
-                 << "(" << static_cast<const void*>(dpy) << ", "
-                 << static_cast<const void*>(vis) << ", " << shareList << ", "
-                 << direct << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCreateContextFn != nullptr);
-  GLXContext result =
-      g_driver_glx.debug_fn.glXCreateContextFn(dpy, vis, shareList, direct);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXContext GL_BINDING_CALL
-Debug_glXCreateContextAttribsARB(Display* dpy,
-                                 GLXFBConfig config,
-                                 GLXContext share_context,
-                                 int direct,
-                                 const int* attrib_list) {
-  GL_SERVICE_LOG("glXCreateContextAttribsARB"
-                 << "(" << static_cast<const void*>(dpy) << ", " << config
-                 << ", " << share_context << ", " << direct << ", "
-                 << static_cast<const void*>(attrib_list) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCreateContextAttribsARBFn != nullptr);
-  GLXContext result = g_driver_glx.debug_fn.glXCreateContextAttribsARBFn(
-      dpy, config, share_context, direct, attrib_list);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXPixmap GL_BINDING_CALL Debug_glXCreateGLXPixmap(Display* dpy,
-                                                          XVisualInfo* visual,
-                                                          Pixmap pixmap) {
-  GL_SERVICE_LOG("glXCreateGLXPixmap"
-                 << "(" << static_cast<const void*>(dpy) << ", "
-                 << static_cast<const void*>(visual) << ", " << pixmap << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCreateGLXPixmapFn != nullptr);
-  GLXPixmap result =
-      g_driver_glx.debug_fn.glXCreateGLXPixmapFn(dpy, visual, pixmap);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXContext GL_BINDING_CALL
-Debug_glXCreateNewContext(Display* dpy,
-                          GLXFBConfig config,
-                          int renderType,
-                          GLXContext shareList,
-                          int direct) {
-  GL_SERVICE_LOG("glXCreateNewContext"
-                 << "(" << static_cast<const void*>(dpy) << ", " << config
-                 << ", " << renderType << ", " << shareList << ", " << direct
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCreateNewContextFn != nullptr);
-  GLXContext result = g_driver_glx.debug_fn.glXCreateNewContextFn(
-      dpy, config, renderType, shareList, direct);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXPbuffer GL_BINDING_CALL
-Debug_glXCreatePbuffer(Display* dpy,
-                       GLXFBConfig config,
-                       const int* attribList) {
-  GL_SERVICE_LOG("glXCreatePbuffer"
-                 << "(" << static_cast<const void*>(dpy) << ", " << config
-                 << ", " << static_cast<const void*>(attribList) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCreatePbufferFn != nullptr);
-  GLXPbuffer result =
-      g_driver_glx.debug_fn.glXCreatePbufferFn(dpy, config, attribList);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXPixmap GL_BINDING_CALL Debug_glXCreatePixmap(Display* dpy,
-                                                       GLXFBConfig config,
-                                                       Pixmap pixmap,
-                                                       const int* attribList) {
-  GL_SERVICE_LOG("glXCreatePixmap"
-                 << "(" << static_cast<const void*>(dpy) << ", " << config
-                 << ", " << pixmap << ", "
-                 << static_cast<const void*>(attribList) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCreatePixmapFn != nullptr);
-  GLXPixmap result =
-      g_driver_glx.debug_fn.glXCreatePixmapFn(dpy, config, pixmap, attribList);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXWindow GL_BINDING_CALL Debug_glXCreateWindow(Display* dpy,
-                                                       GLXFBConfig config,
-                                                       Window win,
-                                                       const int* attribList) {
-  GL_SERVICE_LOG("glXCreateWindow"
-                 << "(" << static_cast<const void*>(dpy) << ", " << config
-                 << ", " << win << ", " << static_cast<const void*>(attribList)
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXCreateWindowFn != nullptr);
-  GLXWindow result =
-      g_driver_glx.debug_fn.glXCreateWindowFn(dpy, config, win, attribList);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glXDestroyContext(Display* dpy,
-                                                    GLXContext ctx) {
-  GL_SERVICE_LOG("glXDestroyContext"
-                 << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
-  DCHECK(g_driver_glx.debug_fn.glXDestroyContextFn != nullptr);
-  g_driver_glx.debug_fn.glXDestroyContextFn(dpy, ctx);
-}
-
-static void GL_BINDING_CALL Debug_glXDestroyGLXPixmap(Display* dpy,
-                                                      GLXPixmap pixmap) {
-  GL_SERVICE_LOG("glXDestroyGLXPixmap"
-                 << "(" << static_cast<const void*>(dpy) << ", " << pixmap
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXDestroyGLXPixmapFn != nullptr);
-  g_driver_glx.debug_fn.glXDestroyGLXPixmapFn(dpy, pixmap);
-}
-
-static void GL_BINDING_CALL Debug_glXDestroyPbuffer(Display* dpy,
-                                                    GLXPbuffer pbuf) {
-  GL_SERVICE_LOG("glXDestroyPbuffer"
-                 << "(" << static_cast<const void*>(dpy) << ", " << pbuf
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXDestroyPbufferFn != nullptr);
-  g_driver_glx.debug_fn.glXDestroyPbufferFn(dpy, pbuf);
-}
-
-static void GL_BINDING_CALL Debug_glXDestroyPixmap(Display* dpy,
-                                                   GLXPixmap pixmap) {
-  GL_SERVICE_LOG("glXDestroyPixmap"
-                 << "(" << static_cast<const void*>(dpy) << ", " << pixmap
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXDestroyPixmapFn != nullptr);
-  g_driver_glx.debug_fn.glXDestroyPixmapFn(dpy, pixmap);
-}
-
-static void GL_BINDING_CALL Debug_glXDestroyWindow(Display* dpy,
-                                                   GLXWindow window) {
-  GL_SERVICE_LOG("glXDestroyWindow"
-                 << "(" << static_cast<const void*>(dpy) << ", " << window
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXDestroyWindowFn != nullptr);
-  g_driver_glx.debug_fn.glXDestroyWindowFn(dpy, window);
-}
-
-static const char* GL_BINDING_CALL Debug_glXGetClientString(Display* dpy,
-                                                            int name) {
-  GL_SERVICE_LOG("glXGetClientString"
-                 << "(" << static_cast<const void*>(dpy) << ", " << name
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetClientStringFn != nullptr);
-  const char* result = g_driver_glx.debug_fn.glXGetClientStringFn(dpy, name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static int GL_BINDING_CALL Debug_glXGetConfig(Display* dpy,
-                                              XVisualInfo* visual,
-                                              int attrib,
-                                              int* value) {
-  GL_SERVICE_LOG("glXGetConfig"
-                 << "(" << static_cast<const void*>(dpy) << ", "
-                 << static_cast<const void*>(visual) << ", " << attrib << ", "
-                 << static_cast<const void*>(value) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetConfigFn != nullptr);
-  int result = g_driver_glx.debug_fn.glXGetConfigFn(dpy, visual, attrib, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXContext GL_BINDING_CALL Debug_glXGetCurrentContext(void) {
-  GL_SERVICE_LOG("glXGetCurrentContext"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetCurrentContextFn != nullptr);
-  GLXContext result = g_driver_glx.debug_fn.glXGetCurrentContextFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static Display* GL_BINDING_CALL Debug_glXGetCurrentDisplay(void) {
-  GL_SERVICE_LOG("glXGetCurrentDisplay"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetCurrentDisplayFn != nullptr);
-  Display* result = g_driver_glx.debug_fn.glXGetCurrentDisplayFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXDrawable GL_BINDING_CALL Debug_glXGetCurrentDrawable(void) {
-  GL_SERVICE_LOG("glXGetCurrentDrawable"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetCurrentDrawableFn != nullptr);
-  GLXDrawable result = g_driver_glx.debug_fn.glXGetCurrentDrawableFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXDrawable GL_BINDING_CALL Debug_glXGetCurrentReadDrawable(void) {
-  GL_SERVICE_LOG("glXGetCurrentReadDrawable"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetCurrentReadDrawableFn != nullptr);
-  GLXDrawable result = g_driver_glx.debug_fn.glXGetCurrentReadDrawableFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static int GL_BINDING_CALL Debug_glXGetFBConfigAttrib(Display* dpy,
-                                                      GLXFBConfig config,
-                                                      int attribute,
-                                                      int* value) {
-  GL_SERVICE_LOG("glXGetFBConfigAttrib"
-                 << "(" << static_cast<const void*>(dpy) << ", " << config
-                 << ", " << attribute << ", " << static_cast<const void*>(value)
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetFBConfigAttribFn != nullptr);
-  int result = g_driver_glx.debug_fn.glXGetFBConfigAttribFn(dpy, config,
-                                                            attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXFBConfig GL_BINDING_CALL
-Debug_glXGetFBConfigFromVisualSGIX(Display* dpy, XVisualInfo* visualInfo) {
-  GL_SERVICE_LOG("glXGetFBConfigFromVisualSGIX"
-                 << "(" << static_cast<const void*>(dpy) << ", "
-                 << static_cast<const void*>(visualInfo) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetFBConfigFromVisualSGIXFn != nullptr);
-  GLXFBConfig result =
-      g_driver_glx.debug_fn.glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLXFBConfig* GL_BINDING_CALL Debug_glXGetFBConfigs(Display* dpy,
-                                                          int screen,
-                                                          int* nelements) {
-  GL_SERVICE_LOG("glXGetFBConfigs"
-                 << "(" << static_cast<const void*>(dpy) << ", " << screen
-                 << ", " << static_cast<const void*>(nelements) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetFBConfigsFn != nullptr);
-  GLXFBConfig* result =
-      g_driver_glx.debug_fn.glXGetFBConfigsFn(dpy, screen, nelements);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static bool GL_BINDING_CALL Debug_glXGetMscRateOML(Display* dpy,
-                                                   GLXDrawable drawable,
-                                                   int32_t* numerator,
-                                                   int32_t* denominator) {
-  GL_SERVICE_LOG("glXGetMscRateOML"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << static_cast<const void*>(numerator) << ", "
-                 << static_cast<const void*>(denominator) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetMscRateOMLFn != nullptr);
-  bool result = g_driver_glx.debug_fn.glXGetMscRateOMLFn(
-      dpy, drawable, numerator, denominator);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glXGetSelectedEvent(Display* dpy,
-                                                      GLXDrawable drawable,
-                                                      unsigned long* mask) {
-  GL_SERVICE_LOG("glXGetSelectedEvent"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << static_cast<const void*>(mask) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetSelectedEventFn != nullptr);
-  g_driver_glx.debug_fn.glXGetSelectedEventFn(dpy, drawable, mask);
-}
-
-static bool GL_BINDING_CALL Debug_glXGetSyncValuesOML(Display* dpy,
-                                                      GLXDrawable drawable,
-                                                      int64_t* ust,
-                                                      int64_t* msc,
-                                                      int64_t* sbc) {
-  GL_SERVICE_LOG("glXGetSyncValuesOML"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << static_cast<const void*>(ust) << ", "
-                 << static_cast<const void*>(msc) << ", "
-                 << static_cast<const void*>(sbc) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetSyncValuesOMLFn != nullptr);
-  bool result =
-      g_driver_glx.debug_fn.glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static XVisualInfo* GL_BINDING_CALL
-Debug_glXGetVisualFromFBConfig(Display* dpy, GLXFBConfig config) {
-  GL_SERVICE_LOG("glXGetVisualFromFBConfig"
-                 << "(" << static_cast<const void*>(dpy) << ", " << config
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXGetVisualFromFBConfigFn != nullptr);
-  XVisualInfo* result =
-      g_driver_glx.debug_fn.glXGetVisualFromFBConfigFn(dpy, config);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static int GL_BINDING_CALL Debug_glXIsDirect(Display* dpy, GLXContext ctx) {
-  GL_SERVICE_LOG("glXIsDirect"
-                 << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
-  DCHECK(g_driver_glx.debug_fn.glXIsDirectFn != nullptr);
-  int result = g_driver_glx.debug_fn.glXIsDirectFn(dpy, ctx);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static int GL_BINDING_CALL Debug_glXMakeContextCurrent(Display* dpy,
-                                                       GLXDrawable draw,
-                                                       GLXDrawable read,
-                                                       GLXContext ctx) {
-  GL_SERVICE_LOG("glXMakeContextCurrent"
-                 << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
-                 << read << ", " << ctx << ")");
-  DCHECK(g_driver_glx.debug_fn.glXMakeContextCurrentFn != nullptr);
-  int result =
-      g_driver_glx.debug_fn.glXMakeContextCurrentFn(dpy, draw, read, ctx);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static int GL_BINDING_CALL Debug_glXMakeCurrent(Display* dpy,
-                                                GLXDrawable drawable,
-                                                GLXContext ctx) {
-  GL_SERVICE_LOG("glXMakeCurrent"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << ctx << ")");
-  DCHECK(g_driver_glx.debug_fn.glXMakeCurrentFn != nullptr);
-  int result = g_driver_glx.debug_fn.glXMakeCurrentFn(dpy, drawable, ctx);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static int GL_BINDING_CALL Debug_glXQueryContext(Display* dpy,
-                                                 GLXContext ctx,
-                                                 int attribute,
-                                                 int* value) {
-  GL_SERVICE_LOG("glXQueryContext"
-                 << "(" << static_cast<const void*>(dpy) << ", " << ctx << ", "
-                 << attribute << ", " << static_cast<const void*>(value)
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXQueryContextFn != nullptr);
-  int result =
-      g_driver_glx.debug_fn.glXQueryContextFn(dpy, ctx, attribute, value);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glXQueryDrawable(Display* dpy,
-                                                   GLXDrawable draw,
-                                                   int attribute,
-                                                   unsigned int* value) {
-  GL_SERVICE_LOG("glXQueryDrawable"
-                 << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
-                 << attribute << ", " << static_cast<const void*>(value)
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXQueryDrawableFn != nullptr);
-  g_driver_glx.debug_fn.glXQueryDrawableFn(dpy, draw, attribute, value);
-}
-
-static int GL_BINDING_CALL Debug_glXQueryExtension(Display* dpy,
-                                                   int* errorb,
-                                                   int* event) {
-  GL_SERVICE_LOG("glXQueryExtension"
-                 << "(" << static_cast<const void*>(dpy) << ", "
-                 << static_cast<const void*>(errorb) << ", "
-                 << static_cast<const void*>(event) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXQueryExtensionFn != nullptr);
-  int result = g_driver_glx.debug_fn.glXQueryExtensionFn(dpy, errorb, event);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static const char* GL_BINDING_CALL Debug_glXQueryExtensionsString(Display* dpy,
-                                                                  int screen) {
-  GL_SERVICE_LOG("glXQueryExtensionsString"
-                 << "(" << static_cast<const void*>(dpy) << ", " << screen
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXQueryExtensionsStringFn != nullptr);
-  const char* result =
-      g_driver_glx.debug_fn.glXQueryExtensionsStringFn(dpy, screen);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static const char* GL_BINDING_CALL Debug_glXQueryServerString(Display* dpy,
-                                                              int screen,
-                                                              int name) {
-  GL_SERVICE_LOG("glXQueryServerString"
-                 << "(" << static_cast<const void*>(dpy) << ", " << screen
-                 << ", " << name << ")");
-  DCHECK(g_driver_glx.debug_fn.glXQueryServerStringFn != nullptr);
-  const char* result =
-      g_driver_glx.debug_fn.glXQueryServerStringFn(dpy, screen, name);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static int GL_BINDING_CALL Debug_glXQueryVersion(Display* dpy,
-                                                 int* maj,
-                                                 int* min) {
-  GL_SERVICE_LOG("glXQueryVersion"
-                 << "(" << static_cast<const void*>(dpy) << ", "
-                 << static_cast<const void*>(maj) << ", "
-                 << static_cast<const void*>(min) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXQueryVersionFn != nullptr);
-  int result = g_driver_glx.debug_fn.glXQueryVersionFn(dpy, maj, min);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glXReleaseTexImageEXT(Display* dpy,
-                                                        GLXDrawable drawable,
-                                                        int buffer) {
-  GL_SERVICE_LOG("glXReleaseTexImageEXT"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << buffer << ")");
-  DCHECK(g_driver_glx.debug_fn.glXReleaseTexImageEXTFn != nullptr);
-  g_driver_glx.debug_fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer);
-}
-
-static void GL_BINDING_CALL Debug_glXSelectEvent(Display* dpy,
-                                                 GLXDrawable drawable,
-                                                 unsigned long mask) {
-  GL_SERVICE_LOG("glXSelectEvent"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << mask << ")");
-  DCHECK(g_driver_glx.debug_fn.glXSelectEventFn != nullptr);
-  g_driver_glx.debug_fn.glXSelectEventFn(dpy, drawable, mask);
-}
-
-static void GL_BINDING_CALL Debug_glXSwapBuffers(Display* dpy,
-                                                 GLXDrawable drawable) {
-  GL_SERVICE_LOG("glXSwapBuffers"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXSwapBuffersFn != nullptr);
-  g_driver_glx.debug_fn.glXSwapBuffersFn(dpy, drawable);
-}
-
-static void GL_BINDING_CALL Debug_glXSwapIntervalEXT(Display* dpy,
-                                                     GLXDrawable drawable,
-                                                     int interval) {
-  GL_SERVICE_LOG("glXSwapIntervalEXT"
-                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
-                 << ", " << interval << ")");
-  DCHECK(g_driver_glx.debug_fn.glXSwapIntervalEXTFn != nullptr);
-  g_driver_glx.debug_fn.glXSwapIntervalEXTFn(dpy, drawable, interval);
-}
-
-static void GL_BINDING_CALL Debug_glXSwapIntervalMESA(unsigned int interval) {
-  GL_SERVICE_LOG("glXSwapIntervalMESA"
-                 << "(" << interval << ")");
-  DCHECK(g_driver_glx.debug_fn.glXSwapIntervalMESAFn != nullptr);
-  g_driver_glx.debug_fn.glXSwapIntervalMESAFn(interval);
-}
-
-static void GL_BINDING_CALL Debug_glXUseXFont(Font font,
-                                              int first,
-                                              int count,
-                                              int list) {
-  GL_SERVICE_LOG("glXUseXFont"
-                 << "(" << font << ", " << first << ", " << count << ", "
-                 << list << ")");
-  DCHECK(g_driver_glx.debug_fn.glXUseXFontFn != nullptr);
-  g_driver_glx.debug_fn.glXUseXFontFn(font, first, count, list);
-}
-
-static void GL_BINDING_CALL Debug_glXWaitGL(void) {
-  GL_SERVICE_LOG("glXWaitGL"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXWaitGLFn != nullptr);
-  g_driver_glx.debug_fn.glXWaitGLFn();
-}
-
-static int GL_BINDING_CALL Debug_glXWaitVideoSyncSGI(int divisor,
-                                                     int remainder,
-                                                     unsigned int* count) {
-  GL_SERVICE_LOG("glXWaitVideoSyncSGI"
-                 << "(" << divisor << ", " << remainder << ", "
-                 << static_cast<const void*>(count) << ")");
-  DCHECK(g_driver_glx.debug_fn.glXWaitVideoSyncSGIFn != nullptr);
-  int result =
-      g_driver_glx.debug_fn.glXWaitVideoSyncSGIFn(divisor, remainder, count);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_glXWaitX(void) {
-  GL_SERVICE_LOG("glXWaitX"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_glx.debug_fn.glXWaitXFn != nullptr);
-  g_driver_glx.debug_fn.glXWaitXFn();
-}
-}  // extern "C"
-
-void DriverGLX::InitializeDebugBindings() {
-  if (!debug_fn.glXBindTexImageEXTFn) {
-    debug_fn.glXBindTexImageEXTFn = fn.glXBindTexImageEXTFn;
-    fn.glXBindTexImageEXTFn = Debug_glXBindTexImageEXT;
-  }
-  if (!debug_fn.glXChooseFBConfigFn) {
-    debug_fn.glXChooseFBConfigFn = fn.glXChooseFBConfigFn;
-    fn.glXChooseFBConfigFn = Debug_glXChooseFBConfig;
-  }
-  if (!debug_fn.glXChooseVisualFn) {
-    debug_fn.glXChooseVisualFn = fn.glXChooseVisualFn;
-    fn.glXChooseVisualFn = Debug_glXChooseVisual;
-  }
-  if (!debug_fn.glXCopyContextFn) {
-    debug_fn.glXCopyContextFn = fn.glXCopyContextFn;
-    fn.glXCopyContextFn = Debug_glXCopyContext;
-  }
-  if (!debug_fn.glXCopySubBufferMESAFn) {
-    debug_fn.glXCopySubBufferMESAFn = fn.glXCopySubBufferMESAFn;
-    fn.glXCopySubBufferMESAFn = Debug_glXCopySubBufferMESA;
-  }
-  if (!debug_fn.glXCreateContextFn) {
-    debug_fn.glXCreateContextFn = fn.glXCreateContextFn;
-    fn.glXCreateContextFn = Debug_glXCreateContext;
-  }
-  if (!debug_fn.glXCreateContextAttribsARBFn) {
-    debug_fn.glXCreateContextAttribsARBFn = fn.glXCreateContextAttribsARBFn;
-    fn.glXCreateContextAttribsARBFn = Debug_glXCreateContextAttribsARB;
-  }
-  if (!debug_fn.glXCreateGLXPixmapFn) {
-    debug_fn.glXCreateGLXPixmapFn = fn.glXCreateGLXPixmapFn;
-    fn.glXCreateGLXPixmapFn = Debug_glXCreateGLXPixmap;
-  }
-  if (!debug_fn.glXCreateNewContextFn) {
-    debug_fn.glXCreateNewContextFn = fn.glXCreateNewContextFn;
-    fn.glXCreateNewContextFn = Debug_glXCreateNewContext;
-  }
-  if (!debug_fn.glXCreatePbufferFn) {
-    debug_fn.glXCreatePbufferFn = fn.glXCreatePbufferFn;
-    fn.glXCreatePbufferFn = Debug_glXCreatePbuffer;
-  }
-  if (!debug_fn.glXCreatePixmapFn) {
-    debug_fn.glXCreatePixmapFn = fn.glXCreatePixmapFn;
-    fn.glXCreatePixmapFn = Debug_glXCreatePixmap;
-  }
-  if (!debug_fn.glXCreateWindowFn) {
-    debug_fn.glXCreateWindowFn = fn.glXCreateWindowFn;
-    fn.glXCreateWindowFn = Debug_glXCreateWindow;
-  }
-  if (!debug_fn.glXDestroyContextFn) {
-    debug_fn.glXDestroyContextFn = fn.glXDestroyContextFn;
-    fn.glXDestroyContextFn = Debug_glXDestroyContext;
-  }
-  if (!debug_fn.glXDestroyGLXPixmapFn) {
-    debug_fn.glXDestroyGLXPixmapFn = fn.glXDestroyGLXPixmapFn;
-    fn.glXDestroyGLXPixmapFn = Debug_glXDestroyGLXPixmap;
-  }
-  if (!debug_fn.glXDestroyPbufferFn) {
-    debug_fn.glXDestroyPbufferFn = fn.glXDestroyPbufferFn;
-    fn.glXDestroyPbufferFn = Debug_glXDestroyPbuffer;
-  }
-  if (!debug_fn.glXDestroyPixmapFn) {
-    debug_fn.glXDestroyPixmapFn = fn.glXDestroyPixmapFn;
-    fn.glXDestroyPixmapFn = Debug_glXDestroyPixmap;
-  }
-  if (!debug_fn.glXDestroyWindowFn) {
-    debug_fn.glXDestroyWindowFn = fn.glXDestroyWindowFn;
-    fn.glXDestroyWindowFn = Debug_glXDestroyWindow;
-  }
-  if (!debug_fn.glXGetClientStringFn) {
-    debug_fn.glXGetClientStringFn = fn.glXGetClientStringFn;
-    fn.glXGetClientStringFn = Debug_glXGetClientString;
-  }
-  if (!debug_fn.glXGetConfigFn) {
-    debug_fn.glXGetConfigFn = fn.glXGetConfigFn;
-    fn.glXGetConfigFn = Debug_glXGetConfig;
-  }
-  if (!debug_fn.glXGetCurrentContextFn) {
-    debug_fn.glXGetCurrentContextFn = fn.glXGetCurrentContextFn;
-    fn.glXGetCurrentContextFn = Debug_glXGetCurrentContext;
-  }
-  if (!debug_fn.glXGetCurrentDisplayFn) {
-    debug_fn.glXGetCurrentDisplayFn = fn.glXGetCurrentDisplayFn;
-    fn.glXGetCurrentDisplayFn = Debug_glXGetCurrentDisplay;
-  }
-  if (!debug_fn.glXGetCurrentDrawableFn) {
-    debug_fn.glXGetCurrentDrawableFn = fn.glXGetCurrentDrawableFn;
-    fn.glXGetCurrentDrawableFn = Debug_glXGetCurrentDrawable;
-  }
-  if (!debug_fn.glXGetCurrentReadDrawableFn) {
-    debug_fn.glXGetCurrentReadDrawableFn = fn.glXGetCurrentReadDrawableFn;
-    fn.glXGetCurrentReadDrawableFn = Debug_glXGetCurrentReadDrawable;
-  }
-  if (!debug_fn.glXGetFBConfigAttribFn) {
-    debug_fn.glXGetFBConfigAttribFn = fn.glXGetFBConfigAttribFn;
-    fn.glXGetFBConfigAttribFn = Debug_glXGetFBConfigAttrib;
-  }
-  if (!debug_fn.glXGetFBConfigFromVisualSGIXFn) {
-    debug_fn.glXGetFBConfigFromVisualSGIXFn = fn.glXGetFBConfigFromVisualSGIXFn;
-    fn.glXGetFBConfigFromVisualSGIXFn = Debug_glXGetFBConfigFromVisualSGIX;
-  }
-  if (!debug_fn.glXGetFBConfigsFn) {
-    debug_fn.glXGetFBConfigsFn = fn.glXGetFBConfigsFn;
-    fn.glXGetFBConfigsFn = Debug_glXGetFBConfigs;
-  }
-  if (!debug_fn.glXGetMscRateOMLFn) {
-    debug_fn.glXGetMscRateOMLFn = fn.glXGetMscRateOMLFn;
-    fn.glXGetMscRateOMLFn = Debug_glXGetMscRateOML;
-  }
-  if (!debug_fn.glXGetSelectedEventFn) {
-    debug_fn.glXGetSelectedEventFn = fn.glXGetSelectedEventFn;
-    fn.glXGetSelectedEventFn = Debug_glXGetSelectedEvent;
-  }
-  if (!debug_fn.glXGetSyncValuesOMLFn) {
-    debug_fn.glXGetSyncValuesOMLFn = fn.glXGetSyncValuesOMLFn;
-    fn.glXGetSyncValuesOMLFn = Debug_glXGetSyncValuesOML;
-  }
-  if (!debug_fn.glXGetVisualFromFBConfigFn) {
-    debug_fn.glXGetVisualFromFBConfigFn = fn.glXGetVisualFromFBConfigFn;
-    fn.glXGetVisualFromFBConfigFn = Debug_glXGetVisualFromFBConfig;
-  }
-  if (!debug_fn.glXIsDirectFn) {
-    debug_fn.glXIsDirectFn = fn.glXIsDirectFn;
-    fn.glXIsDirectFn = Debug_glXIsDirect;
-  }
-  if (!debug_fn.glXMakeContextCurrentFn) {
-    debug_fn.glXMakeContextCurrentFn = fn.glXMakeContextCurrentFn;
-    fn.glXMakeContextCurrentFn = Debug_glXMakeContextCurrent;
-  }
-  if (!debug_fn.glXMakeCurrentFn) {
-    debug_fn.glXMakeCurrentFn = fn.glXMakeCurrentFn;
-    fn.glXMakeCurrentFn = Debug_glXMakeCurrent;
-  }
-  if (!debug_fn.glXQueryContextFn) {
-    debug_fn.glXQueryContextFn = fn.glXQueryContextFn;
-    fn.glXQueryContextFn = Debug_glXQueryContext;
-  }
-  if (!debug_fn.glXQueryDrawableFn) {
-    debug_fn.glXQueryDrawableFn = fn.glXQueryDrawableFn;
-    fn.glXQueryDrawableFn = Debug_glXQueryDrawable;
-  }
-  if (!debug_fn.glXQueryExtensionFn) {
-    debug_fn.glXQueryExtensionFn = fn.glXQueryExtensionFn;
-    fn.glXQueryExtensionFn = Debug_glXQueryExtension;
-  }
-  if (!debug_fn.glXQueryExtensionsStringFn) {
-    debug_fn.glXQueryExtensionsStringFn = fn.glXQueryExtensionsStringFn;
-    fn.glXQueryExtensionsStringFn = Debug_glXQueryExtensionsString;
-  }
-  if (!debug_fn.glXQueryServerStringFn) {
-    debug_fn.glXQueryServerStringFn = fn.glXQueryServerStringFn;
-    fn.glXQueryServerStringFn = Debug_glXQueryServerString;
-  }
-  if (!debug_fn.glXQueryVersionFn) {
-    debug_fn.glXQueryVersionFn = fn.glXQueryVersionFn;
-    fn.glXQueryVersionFn = Debug_glXQueryVersion;
-  }
-  if (!debug_fn.glXReleaseTexImageEXTFn) {
-    debug_fn.glXReleaseTexImageEXTFn = fn.glXReleaseTexImageEXTFn;
-    fn.glXReleaseTexImageEXTFn = Debug_glXReleaseTexImageEXT;
-  }
-  if (!debug_fn.glXSelectEventFn) {
-    debug_fn.glXSelectEventFn = fn.glXSelectEventFn;
-    fn.glXSelectEventFn = Debug_glXSelectEvent;
-  }
-  if (!debug_fn.glXSwapBuffersFn) {
-    debug_fn.glXSwapBuffersFn = fn.glXSwapBuffersFn;
-    fn.glXSwapBuffersFn = Debug_glXSwapBuffers;
-  }
-  if (!debug_fn.glXSwapIntervalEXTFn) {
-    debug_fn.glXSwapIntervalEXTFn = fn.glXSwapIntervalEXTFn;
-    fn.glXSwapIntervalEXTFn = Debug_glXSwapIntervalEXT;
-  }
-  if (!debug_fn.glXSwapIntervalMESAFn) {
-    debug_fn.glXSwapIntervalMESAFn = fn.glXSwapIntervalMESAFn;
-    fn.glXSwapIntervalMESAFn = Debug_glXSwapIntervalMESA;
-  }
-  if (!debug_fn.glXUseXFontFn) {
-    debug_fn.glXUseXFontFn = fn.glXUseXFontFn;
-    fn.glXUseXFontFn = Debug_glXUseXFont;
-  }
-  if (!debug_fn.glXWaitGLFn) {
-    debug_fn.glXWaitGLFn = fn.glXWaitGLFn;
-    fn.glXWaitGLFn = Debug_glXWaitGL;
-  }
-  if (!debug_fn.glXWaitVideoSyncSGIFn) {
-    debug_fn.glXWaitVideoSyncSGIFn = fn.glXWaitVideoSyncSGIFn;
-    fn.glXWaitVideoSyncSGIFn = Debug_glXWaitVideoSyncSGI;
-  }
-  if (!debug_fn.glXWaitXFn) {
-    debug_fn.glXWaitXFn = fn.glXWaitXFn;
-    fn.glXWaitXFn = Debug_glXWaitX;
-  }
-  g_debugBindingsInitialized = true;
 }
 
 void DriverGLX::ClearBindings() {
@@ -1573,4 +785,498 @@ void TraceGLXApi::glXWaitXFn(void) {
   glx_api_->glXWaitXFn();
 }
 
+void DebugGLXApi::glXBindTexImageEXTFn(Display* dpy,
+                                       GLXDrawable drawable,
+                                       int buffer,
+                                       int* attribList) {
+  GL_SERVICE_LOG("glXBindTexImageEXT"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << buffer << ", "
+                 << static_cast<const void*>(attribList) << ")");
+  glx_api_->glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
+}
+
+GLXFBConfig* DebugGLXApi::glXChooseFBConfigFn(Display* dpy,
+                                              int screen,
+                                              const int* attribList,
+                                              int* nitems) {
+  GL_SERVICE_LOG("glXChooseFBConfig"
+                 << "(" << static_cast<const void*>(dpy) << ", " << screen
+                 << ", " << static_cast<const void*>(attribList) << ", "
+                 << static_cast<const void*>(nitems) << ")");
+  GLXFBConfig* result =
+      glx_api_->glXChooseFBConfigFn(dpy, screen, attribList, nitems);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+XVisualInfo* DebugGLXApi::glXChooseVisualFn(Display* dpy,
+                                            int screen,
+                                            int* attribList) {
+  GL_SERVICE_LOG("glXChooseVisual"
+                 << "(" << static_cast<const void*>(dpy) << ", " << screen
+                 << ", " << static_cast<const void*>(attribList) << ")");
+  XVisualInfo* result = glx_api_->glXChooseVisualFn(dpy, screen, attribList);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLXApi::glXCopyContextFn(Display* dpy,
+                                   GLXContext src,
+                                   GLXContext dst,
+                                   unsigned long mask) {
+  GL_SERVICE_LOG("glXCopyContext"
+                 << "(" << static_cast<const void*>(dpy) << ", " << src << ", "
+                 << dst << ", " << mask << ")");
+  glx_api_->glXCopyContextFn(dpy, src, dst, mask);
+}
+
+void DebugGLXApi::glXCopySubBufferMESAFn(Display* dpy,
+                                         GLXDrawable drawable,
+                                         int x,
+                                         int y,
+                                         int width,
+                                         int height) {
+  GL_SERVICE_LOG("glXCopySubBufferMESA"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << x << ", " << y << ", " << width << ", " << height
+                 << ")");
+  glx_api_->glXCopySubBufferMESAFn(dpy, drawable, x, y, width, height);
+}
+
+GLXContext DebugGLXApi::glXCreateContextFn(Display* dpy,
+                                           XVisualInfo* vis,
+                                           GLXContext shareList,
+                                           int direct) {
+  GL_SERVICE_LOG("glXCreateContext"
+                 << "(" << static_cast<const void*>(dpy) << ", "
+                 << static_cast<const void*>(vis) << ", " << shareList << ", "
+                 << direct << ")");
+  GLXContext result = glx_api_->glXCreateContextFn(dpy, vis, shareList, direct);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXContext DebugGLXApi::glXCreateContextAttribsARBFn(Display* dpy,
+                                                     GLXFBConfig config,
+                                                     GLXContext share_context,
+                                                     int direct,
+                                                     const int* attrib_list) {
+  GL_SERVICE_LOG("glXCreateContextAttribsARB"
+                 << "(" << static_cast<const void*>(dpy) << ", " << config
+                 << ", " << share_context << ", " << direct << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  GLXContext result = glx_api_->glXCreateContextAttribsARBFn(
+      dpy, config, share_context, direct, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXPixmap DebugGLXApi::glXCreateGLXPixmapFn(Display* dpy,
+                                            XVisualInfo* visual,
+                                            Pixmap pixmap) {
+  GL_SERVICE_LOG("glXCreateGLXPixmap"
+                 << "(" << static_cast<const void*>(dpy) << ", "
+                 << static_cast<const void*>(visual) << ", " << pixmap << ")");
+  GLXPixmap result = glx_api_->glXCreateGLXPixmapFn(dpy, visual, pixmap);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXContext DebugGLXApi::glXCreateNewContextFn(Display* dpy,
+                                              GLXFBConfig config,
+                                              int renderType,
+                                              GLXContext shareList,
+                                              int direct) {
+  GL_SERVICE_LOG("glXCreateNewContext"
+                 << "(" << static_cast<const void*>(dpy) << ", " << config
+                 << ", " << renderType << ", " << shareList << ", " << direct
+                 << ")");
+  GLXContext result = glx_api_->glXCreateNewContextFn(dpy, config, renderType,
+                                                      shareList, direct);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXPbuffer DebugGLXApi::glXCreatePbufferFn(Display* dpy,
+                                           GLXFBConfig config,
+                                           const int* attribList) {
+  GL_SERVICE_LOG("glXCreatePbuffer"
+                 << "(" << static_cast<const void*>(dpy) << ", " << config
+                 << ", " << static_cast<const void*>(attribList) << ")");
+  GLXPbuffer result = glx_api_->glXCreatePbufferFn(dpy, config, attribList);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXPixmap DebugGLXApi::glXCreatePixmapFn(Display* dpy,
+                                         GLXFBConfig config,
+                                         Pixmap pixmap,
+                                         const int* attribList) {
+  GL_SERVICE_LOG("glXCreatePixmap"
+                 << "(" << static_cast<const void*>(dpy) << ", " << config
+                 << ", " << pixmap << ", "
+                 << static_cast<const void*>(attribList) << ")");
+  GLXPixmap result =
+      glx_api_->glXCreatePixmapFn(dpy, config, pixmap, attribList);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXWindow DebugGLXApi::glXCreateWindowFn(Display* dpy,
+                                         GLXFBConfig config,
+                                         Window win,
+                                         const int* attribList) {
+  GL_SERVICE_LOG("glXCreateWindow"
+                 << "(" << static_cast<const void*>(dpy) << ", " << config
+                 << ", " << win << ", " << static_cast<const void*>(attribList)
+                 << ")");
+  GLXWindow result = glx_api_->glXCreateWindowFn(dpy, config, win, attribList);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLXApi::glXDestroyContextFn(Display* dpy, GLXContext ctx) {
+  GL_SERVICE_LOG("glXDestroyContext"
+                 << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
+  glx_api_->glXDestroyContextFn(dpy, ctx);
+}
+
+void DebugGLXApi::glXDestroyGLXPixmapFn(Display* dpy, GLXPixmap pixmap) {
+  GL_SERVICE_LOG("glXDestroyGLXPixmap"
+                 << "(" << static_cast<const void*>(dpy) << ", " << pixmap
+                 << ")");
+  glx_api_->glXDestroyGLXPixmapFn(dpy, pixmap);
+}
+
+void DebugGLXApi::glXDestroyPbufferFn(Display* dpy, GLXPbuffer pbuf) {
+  GL_SERVICE_LOG("glXDestroyPbuffer"
+                 << "(" << static_cast<const void*>(dpy) << ", " << pbuf
+                 << ")");
+  glx_api_->glXDestroyPbufferFn(dpy, pbuf);
+}
+
+void DebugGLXApi::glXDestroyPixmapFn(Display* dpy, GLXPixmap pixmap) {
+  GL_SERVICE_LOG("glXDestroyPixmap"
+                 << "(" << static_cast<const void*>(dpy) << ", " << pixmap
+                 << ")");
+  glx_api_->glXDestroyPixmapFn(dpy, pixmap);
+}
+
+void DebugGLXApi::glXDestroyWindowFn(Display* dpy, GLXWindow window) {
+  GL_SERVICE_LOG("glXDestroyWindow"
+                 << "(" << static_cast<const void*>(dpy) << ", " << window
+                 << ")");
+  glx_api_->glXDestroyWindowFn(dpy, window);
+}
+
+const char* DebugGLXApi::glXGetClientStringFn(Display* dpy, int name) {
+  GL_SERVICE_LOG("glXGetClientString"
+                 << "(" << static_cast<const void*>(dpy) << ", " << name
+                 << ")");
+  const char* result = glx_api_->glXGetClientStringFn(dpy, name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+int DebugGLXApi::glXGetConfigFn(Display* dpy,
+                                XVisualInfo* visual,
+                                int attrib,
+                                int* value) {
+  GL_SERVICE_LOG("glXGetConfig"
+                 << "(" << static_cast<const void*>(dpy) << ", "
+                 << static_cast<const void*>(visual) << ", " << attrib << ", "
+                 << static_cast<const void*>(value) << ")");
+  int result = glx_api_->glXGetConfigFn(dpy, visual, attrib, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXContext DebugGLXApi::glXGetCurrentContextFn(void) {
+  GL_SERVICE_LOG("glXGetCurrentContext"
+                 << "("
+                 << ")");
+  GLXContext result = glx_api_->glXGetCurrentContextFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+Display* DebugGLXApi::glXGetCurrentDisplayFn(void) {
+  GL_SERVICE_LOG("glXGetCurrentDisplay"
+                 << "("
+                 << ")");
+  Display* result = glx_api_->glXGetCurrentDisplayFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXDrawable DebugGLXApi::glXGetCurrentDrawableFn(void) {
+  GL_SERVICE_LOG("glXGetCurrentDrawable"
+                 << "("
+                 << ")");
+  GLXDrawable result = glx_api_->glXGetCurrentDrawableFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXDrawable DebugGLXApi::glXGetCurrentReadDrawableFn(void) {
+  GL_SERVICE_LOG("glXGetCurrentReadDrawable"
+                 << "("
+                 << ")");
+  GLXDrawable result = glx_api_->glXGetCurrentReadDrawableFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+int DebugGLXApi::glXGetFBConfigAttribFn(Display* dpy,
+                                        GLXFBConfig config,
+                                        int attribute,
+                                        int* value) {
+  GL_SERVICE_LOG("glXGetFBConfigAttrib"
+                 << "(" << static_cast<const void*>(dpy) << ", " << config
+                 << ", " << attribute << ", " << static_cast<const void*>(value)
+                 << ")");
+  int result = glx_api_->glXGetFBConfigAttribFn(dpy, config, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXFBConfig DebugGLXApi::glXGetFBConfigFromVisualSGIXFn(
+    Display* dpy,
+    XVisualInfo* visualInfo) {
+  GL_SERVICE_LOG("glXGetFBConfigFromVisualSGIX"
+                 << "(" << static_cast<const void*>(dpy) << ", "
+                 << static_cast<const void*>(visualInfo) << ")");
+  GLXFBConfig result =
+      glx_api_->glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLXFBConfig* DebugGLXApi::glXGetFBConfigsFn(Display* dpy,
+                                            int screen,
+                                            int* nelements) {
+  GL_SERVICE_LOG("glXGetFBConfigs"
+                 << "(" << static_cast<const void*>(dpy) << ", " << screen
+                 << ", " << static_cast<const void*>(nelements) << ")");
+  GLXFBConfig* result = glx_api_->glXGetFBConfigsFn(dpy, screen, nelements);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+bool DebugGLXApi::glXGetMscRateOMLFn(Display* dpy,
+                                     GLXDrawable drawable,
+                                     int32_t* numerator,
+                                     int32_t* denominator) {
+  GL_SERVICE_LOG("glXGetMscRateOML"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << static_cast<const void*>(numerator) << ", "
+                 << static_cast<const void*>(denominator) << ")");
+  bool result =
+      glx_api_->glXGetMscRateOMLFn(dpy, drawable, numerator, denominator);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLXApi::glXGetSelectedEventFn(Display* dpy,
+                                        GLXDrawable drawable,
+                                        unsigned long* mask) {
+  GL_SERVICE_LOG("glXGetSelectedEvent"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << static_cast<const void*>(mask) << ")");
+  glx_api_->glXGetSelectedEventFn(dpy, drawable, mask);
+}
+
+bool DebugGLXApi::glXGetSyncValuesOMLFn(Display* dpy,
+                                        GLXDrawable drawable,
+                                        int64_t* ust,
+                                        int64_t* msc,
+                                        int64_t* sbc) {
+  GL_SERVICE_LOG("glXGetSyncValuesOML"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << static_cast<const void*>(ust) << ", "
+                 << static_cast<const void*>(msc) << ", "
+                 << static_cast<const void*>(sbc) << ")");
+  bool result = glx_api_->glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+XVisualInfo* DebugGLXApi::glXGetVisualFromFBConfigFn(Display* dpy,
+                                                     GLXFBConfig config) {
+  GL_SERVICE_LOG("glXGetVisualFromFBConfig"
+                 << "(" << static_cast<const void*>(dpy) << ", " << config
+                 << ")");
+  XVisualInfo* result = glx_api_->glXGetVisualFromFBConfigFn(dpy, config);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+int DebugGLXApi::glXIsDirectFn(Display* dpy, GLXContext ctx) {
+  GL_SERVICE_LOG("glXIsDirect"
+                 << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
+  int result = glx_api_->glXIsDirectFn(dpy, ctx);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+int DebugGLXApi::glXMakeContextCurrentFn(Display* dpy,
+                                         GLXDrawable draw,
+                                         GLXDrawable read,
+                                         GLXContext ctx) {
+  GL_SERVICE_LOG("glXMakeContextCurrent"
+                 << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
+                 << read << ", " << ctx << ")");
+  int result = glx_api_->glXMakeContextCurrentFn(dpy, draw, read, ctx);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+int DebugGLXApi::glXMakeCurrentFn(Display* dpy,
+                                  GLXDrawable drawable,
+                                  GLXContext ctx) {
+  GL_SERVICE_LOG("glXMakeCurrent"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << ctx << ")");
+  int result = glx_api_->glXMakeCurrentFn(dpy, drawable, ctx);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+int DebugGLXApi::glXQueryContextFn(Display* dpy,
+                                   GLXContext ctx,
+                                   int attribute,
+                                   int* value) {
+  GL_SERVICE_LOG("glXQueryContext"
+                 << "(" << static_cast<const void*>(dpy) << ", " << ctx << ", "
+                 << attribute << ", " << static_cast<const void*>(value)
+                 << ")");
+  int result = glx_api_->glXQueryContextFn(dpy, ctx, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLXApi::glXQueryDrawableFn(Display* dpy,
+                                     GLXDrawable draw,
+                                     int attribute,
+                                     unsigned int* value) {
+  GL_SERVICE_LOG("glXQueryDrawable"
+                 << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
+                 << attribute << ", " << static_cast<const void*>(value)
+                 << ")");
+  glx_api_->glXQueryDrawableFn(dpy, draw, attribute, value);
+}
+
+int DebugGLXApi::glXQueryExtensionFn(Display* dpy, int* errorb, int* event) {
+  GL_SERVICE_LOG("glXQueryExtension"
+                 << "(" << static_cast<const void*>(dpy) << ", "
+                 << static_cast<const void*>(errorb) << ", "
+                 << static_cast<const void*>(event) << ")");
+  int result = glx_api_->glXQueryExtensionFn(dpy, errorb, event);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+const char* DebugGLXApi::glXQueryExtensionsStringFn(Display* dpy, int screen) {
+  GL_SERVICE_LOG("glXQueryExtensionsString"
+                 << "(" << static_cast<const void*>(dpy) << ", " << screen
+                 << ")");
+  const char* result = glx_api_->glXQueryExtensionsStringFn(dpy, screen);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+const char* DebugGLXApi::glXQueryServerStringFn(Display* dpy,
+                                                int screen,
+                                                int name) {
+  GL_SERVICE_LOG("glXQueryServerString"
+                 << "(" << static_cast<const void*>(dpy) << ", " << screen
+                 << ", " << name << ")");
+  const char* result = glx_api_->glXQueryServerStringFn(dpy, screen, name);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+int DebugGLXApi::glXQueryVersionFn(Display* dpy, int* maj, int* min) {
+  GL_SERVICE_LOG("glXQueryVersion"
+                 << "(" << static_cast<const void*>(dpy) << ", "
+                 << static_cast<const void*>(maj) << ", "
+                 << static_cast<const void*>(min) << ")");
+  int result = glx_api_->glXQueryVersionFn(dpy, maj, min);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLXApi::glXReleaseTexImageEXTFn(Display* dpy,
+                                          GLXDrawable drawable,
+                                          int buffer) {
+  GL_SERVICE_LOG("glXReleaseTexImageEXT"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << buffer << ")");
+  glx_api_->glXReleaseTexImageEXTFn(dpy, drawable, buffer);
+}
+
+void DebugGLXApi::glXSelectEventFn(Display* dpy,
+                                   GLXDrawable drawable,
+                                   unsigned long mask) {
+  GL_SERVICE_LOG("glXSelectEvent"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << mask << ")");
+  glx_api_->glXSelectEventFn(dpy, drawable, mask);
+}
+
+void DebugGLXApi::glXSwapBuffersFn(Display* dpy, GLXDrawable drawable) {
+  GL_SERVICE_LOG("glXSwapBuffers"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ")");
+  glx_api_->glXSwapBuffersFn(dpy, drawable);
+}
+
+void DebugGLXApi::glXSwapIntervalEXTFn(Display* dpy,
+                                       GLXDrawable drawable,
+                                       int interval) {
+  GL_SERVICE_LOG("glXSwapIntervalEXT"
+                 << "(" << static_cast<const void*>(dpy) << ", " << drawable
+                 << ", " << interval << ")");
+  glx_api_->glXSwapIntervalEXTFn(dpy, drawable, interval);
+}
+
+void DebugGLXApi::glXSwapIntervalMESAFn(unsigned int interval) {
+  GL_SERVICE_LOG("glXSwapIntervalMESA"
+                 << "(" << interval << ")");
+  glx_api_->glXSwapIntervalMESAFn(interval);
+}
+
+void DebugGLXApi::glXUseXFontFn(Font font, int first, int count, int list) {
+  GL_SERVICE_LOG("glXUseXFont"
+                 << "(" << font << ", " << first << ", " << count << ", "
+                 << list << ")");
+  glx_api_->glXUseXFontFn(font, first, count, list);
+}
+
+void DebugGLXApi::glXWaitGLFn(void) {
+  GL_SERVICE_LOG("glXWaitGL"
+                 << "("
+                 << ")");
+  glx_api_->glXWaitGLFn();
+}
+
+int DebugGLXApi::glXWaitVideoSyncSGIFn(int divisor,
+                                       int remainder,
+                                       unsigned int* count) {
+  GL_SERVICE_LOG("glXWaitVideoSyncSGI"
+                 << "(" << divisor << ", " << remainder << ", "
+                 << static_cast<const void*>(count) << ")");
+  int result = glx_api_->glXWaitVideoSyncSGIFn(divisor, remainder, count);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugGLXApi::glXWaitXFn(void) {
+  GL_SERVICE_LOG("glXWaitX"
+                 << "("
+                 << ")");
+  glx_api_->glXWaitXFn();
+}
+
 }  // namespace gl
diff --git a/chromium/ui/gl/gl_bindings_autogen_osmesa.cc b/chromium/ui/gl/gl_bindings_autogen_osmesa.cc
index 7756f8a6014..27185e32f95 100644
--- a/chromium/ui/gl/gl_bindings_autogen_osmesa.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_osmesa.cc
@@ -20,7 +20,6 @@
 
 namespace gl {
 
-static bool g_debugBindingsInitialized;
 DriverOSMESA g_driver_osmesa;
 
 void DriverOSMESA::InitializeStaticBindings() {
@@ -52,188 +51,6 @@ void DriverOSMESA::InitializeExtensionBindings() {
   std::string extensions(GetPlatformExtensions());
   extensions += " ";
   ALLOW_UNUSED_LOCAL(extensions);
-
-  if (g_debugBindingsInitialized)
-    InitializeDebugBindings();
-}
-
-extern "C" {
-
-static void GL_BINDING_CALL Debug_OSMesaColorClamp(GLboolean enable) {
-  GL_SERVICE_LOG("OSMesaColorClamp"
-                 << "(" << GLEnums::GetStringBool(enable) << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaColorClampFn != nullptr);
-  g_driver_osmesa.debug_fn.OSMesaColorClampFn(enable);
-}
-
-static OSMesaContext GL_BINDING_CALL
-Debug_OSMesaCreateContext(GLenum format, OSMesaContext sharelist) {
-  GL_SERVICE_LOG("OSMesaCreateContext"
-                 << "(" << GLEnums::GetStringEnum(format) << ", " << sharelist
-                 << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaCreateContextFn != nullptr);
-  OSMesaContext result =
-      g_driver_osmesa.debug_fn.OSMesaCreateContextFn(format, sharelist);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static OSMesaContext GL_BINDING_CALL
-Debug_OSMesaCreateContextExt(GLenum format,
-                             GLint depthBits,
-                             GLint stencilBits,
-                             GLint accumBits,
-                             OSMesaContext sharelist) {
-  GL_SERVICE_LOG("OSMesaCreateContextExt"
-                 << "(" << GLEnums::GetStringEnum(format) << ", " << depthBits
-                 << ", " << stencilBits << ", " << accumBits << ", "
-                 << sharelist << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaCreateContextExtFn != nullptr);
-  OSMesaContext result = g_driver_osmesa.debug_fn.OSMesaCreateContextExtFn(
-      format, depthBits, stencilBits, accumBits, sharelist);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_OSMesaDestroyContext(OSMesaContext ctx) {
-  GL_SERVICE_LOG("OSMesaDestroyContext"
-                 << "(" << ctx << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaDestroyContextFn != nullptr);
-  g_driver_osmesa.debug_fn.OSMesaDestroyContextFn(ctx);
-}
-
-static GLboolean GL_BINDING_CALL Debug_OSMesaGetColorBuffer(OSMesaContext c,
-                                                            GLint* width,
-                                                            GLint* height,
-                                                            GLint* format,
-                                                            void** buffer) {
-  GL_SERVICE_LOG("OSMesaGetColorBuffer"
-                 << "(" << c << ", " << static_cast<const void*>(width) << ", "
-                 << static_cast<const void*>(height) << ", "
-                 << static_cast<const void*>(format) << ", " << buffer << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaGetColorBufferFn != nullptr);
-  GLboolean result = g_driver_osmesa.debug_fn.OSMesaGetColorBufferFn(
-      c, width, height, format, buffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static OSMesaContext GL_BINDING_CALL Debug_OSMesaGetCurrentContext(void) {
-  GL_SERVICE_LOG("OSMesaGetCurrentContext"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaGetCurrentContextFn != nullptr);
-  OSMesaContext result = g_driver_osmesa.debug_fn.OSMesaGetCurrentContextFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL
-Debug_OSMesaGetDepthBuffer(OSMesaContext c,
-                           GLint* width,
-                           GLint* height,
-                           GLint* bytesPerValue,
-                           void** buffer) {
-  GL_SERVICE_LOG("OSMesaGetDepthBuffer"
-                 << "(" << c << ", " << static_cast<const void*>(width) << ", "
-                 << static_cast<const void*>(height) << ", "
-                 << static_cast<const void*>(bytesPerValue) << ", " << buffer
-                 << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaGetDepthBufferFn != nullptr);
-  GLboolean result = g_driver_osmesa.debug_fn.OSMesaGetDepthBufferFn(
-      c, width, height, bytesPerValue, buffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_OSMesaGetIntegerv(GLint pname, GLint* value) {
-  GL_SERVICE_LOG("OSMesaGetIntegerv"
-                 << "(" << pname << ", " << static_cast<const void*>(value)
-                 << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaGetIntegervFn != nullptr);
-  g_driver_osmesa.debug_fn.OSMesaGetIntegervFn(pname, value);
-}
-
-static OSMESAproc GL_BINDING_CALL
-Debug_OSMesaGetProcAddress(const char* funcName) {
-  GL_SERVICE_LOG("OSMesaGetProcAddress"
-                 << "(" << funcName << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaGetProcAddressFn != nullptr);
-  OSMESAproc result = g_driver_osmesa.debug_fn.OSMesaGetProcAddressFn(funcName);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static GLboolean GL_BINDING_CALL Debug_OSMesaMakeCurrent(OSMesaContext ctx,
-                                                         void* buffer,
-                                                         GLenum type,
-                                                         GLsizei width,
-                                                         GLsizei height) {
-  GL_SERVICE_LOG("OSMesaMakeCurrent"
-                 << "(" << ctx << ", " << static_cast<const void*>(buffer)
-                 << ", " << GLEnums::GetStringEnum(type) << ", " << width
-                 << ", " << height << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaMakeCurrentFn != nullptr);
-  GLboolean result = g_driver_osmesa.debug_fn.OSMesaMakeCurrentFn(
-      ctx, buffer, type, width, height);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static void GL_BINDING_CALL Debug_OSMesaPixelStore(GLint pname, GLint value) {
-  GL_SERVICE_LOG("OSMesaPixelStore"
-                 << "(" << pname << ", " << value << ")");
-  DCHECK(g_driver_osmesa.debug_fn.OSMesaPixelStoreFn != nullptr);
-  g_driver_osmesa.debug_fn.OSMesaPixelStoreFn(pname, value);
-}
-}  // extern "C"
-
-void DriverOSMESA::InitializeDebugBindings() {
-  if (!debug_fn.OSMesaColorClampFn) {
-    debug_fn.OSMesaColorClampFn = fn.OSMesaColorClampFn;
-    fn.OSMesaColorClampFn = Debug_OSMesaColorClamp;
-  }
-  if (!debug_fn.OSMesaCreateContextFn) {
-    debug_fn.OSMesaCreateContextFn = fn.OSMesaCreateContextFn;
-    fn.OSMesaCreateContextFn = Debug_OSMesaCreateContext;
-  }
-  if (!debug_fn.OSMesaCreateContextExtFn) {
-    debug_fn.OSMesaCreateContextExtFn = fn.OSMesaCreateContextExtFn;
-    fn.OSMesaCreateContextExtFn = Debug_OSMesaCreateContextExt;
-  }
-  if (!debug_fn.OSMesaDestroyContextFn) {
-    debug_fn.OSMesaDestroyContextFn = fn.OSMesaDestroyContextFn;
-    fn.OSMesaDestroyContextFn = Debug_OSMesaDestroyContext;
-  }
-  if (!debug_fn.OSMesaGetColorBufferFn) {
-    debug_fn.OSMesaGetColorBufferFn = fn.OSMesaGetColorBufferFn;
-    fn.OSMesaGetColorBufferFn = Debug_OSMesaGetColorBuffer;
-  }
-  if (!debug_fn.OSMesaGetCurrentContextFn) {
-    debug_fn.OSMesaGetCurrentContextFn = fn.OSMesaGetCurrentContextFn;
-    fn.OSMesaGetCurrentContextFn = Debug_OSMesaGetCurrentContext;
-  }
-  if (!debug_fn.OSMesaGetDepthBufferFn) {
-    debug_fn.OSMesaGetDepthBufferFn = fn.OSMesaGetDepthBufferFn;
-    fn.OSMesaGetDepthBufferFn = Debug_OSMesaGetDepthBuffer;
-  }
-  if (!debug_fn.OSMesaGetIntegervFn) {
-    debug_fn.OSMesaGetIntegervFn = fn.OSMesaGetIntegervFn;
-    fn.OSMesaGetIntegervFn = Debug_OSMesaGetIntegerv;
-  }
-  if (!debug_fn.OSMesaGetProcAddressFn) {
-    debug_fn.OSMesaGetProcAddressFn = fn.OSMesaGetProcAddressFn;
-    fn.OSMesaGetProcAddressFn = Debug_OSMesaGetProcAddress;
-  }
-  if (!debug_fn.OSMesaMakeCurrentFn) {
-    debug_fn.OSMesaMakeCurrentFn = fn.OSMesaMakeCurrentFn;
-    fn.OSMesaMakeCurrentFn = Debug_OSMesaMakeCurrent;
-  }
-  if (!debug_fn.OSMesaPixelStoreFn) {
-    debug_fn.OSMesaPixelStoreFn = fn.OSMesaPixelStoreFn;
-    fn.OSMesaPixelStoreFn = Debug_OSMesaPixelStore;
-  }
-  g_debugBindingsInitialized = true;
 }
 
 void DriverOSMESA::ClearBindings() {
@@ -378,4 +195,118 @@ void TraceOSMESAApi::OSMesaPixelStoreFn(GLint pname, GLint value) {
   osmesa_api_->OSMesaPixelStoreFn(pname, value);
 }
 
+void DebugOSMESAApi::OSMesaColorClampFn(GLboolean enable) {
+  GL_SERVICE_LOG("OSMesaColorClamp"
+                 << "(" << GLEnums::GetStringBool(enable) << ")");
+  osmesa_api_->OSMesaColorClampFn(enable);
+}
+
+OSMesaContext DebugOSMESAApi::OSMesaCreateContextFn(GLenum format,
+                                                    OSMesaContext sharelist) {
+  GL_SERVICE_LOG("OSMesaCreateContext"
+                 << "(" << GLEnums::GetStringEnum(format) << ", " << sharelist
+                 << ")");
+  OSMesaContext result = osmesa_api_->OSMesaCreateContextFn(format, sharelist);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+OSMesaContext DebugOSMESAApi::OSMesaCreateContextExtFn(
+    GLenum format,
+    GLint depthBits,
+    GLint stencilBits,
+    GLint accumBits,
+    OSMesaContext sharelist) {
+  GL_SERVICE_LOG("OSMesaCreateContextExt"
+                 << "(" << GLEnums::GetStringEnum(format) << ", " << depthBits
+                 << ", " << stencilBits << ", " << accumBits << ", "
+                 << sharelist << ")");
+  OSMesaContext result = osmesa_api_->OSMesaCreateContextExtFn(
+      format, depthBits, stencilBits, accumBits, sharelist);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugOSMESAApi::OSMesaDestroyContextFn(OSMesaContext ctx) {
+  GL_SERVICE_LOG("OSMesaDestroyContext"
+                 << "(" << ctx << ")");
+  osmesa_api_->OSMesaDestroyContextFn(ctx);
+}
+
+GLboolean DebugOSMESAApi::OSMesaGetColorBufferFn(OSMesaContext c,
+                                                 GLint* width,
+                                                 GLint* height,
+                                                 GLint* format,
+                                                 void** buffer) {
+  GL_SERVICE_LOG("OSMesaGetColorBuffer"
+                 << "(" << c << ", " << static_cast<const void*>(width) << ", "
+                 << static_cast<const void*>(height) << ", "
+                 << static_cast<const void*>(format) << ", " << buffer << ")");
+  GLboolean result =
+      osmesa_api_->OSMesaGetColorBufferFn(c, width, height, format, buffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+OSMesaContext DebugOSMESAApi::OSMesaGetCurrentContextFn(void) {
+  GL_SERVICE_LOG("OSMesaGetCurrentContext"
+                 << "("
+                 << ")");
+  OSMesaContext result = osmesa_api_->OSMesaGetCurrentContextFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugOSMESAApi::OSMesaGetDepthBufferFn(OSMesaContext c,
+                                                 GLint* width,
+                                                 GLint* height,
+                                                 GLint* bytesPerValue,
+                                                 void** buffer) {
+  GL_SERVICE_LOG("OSMesaGetDepthBuffer"
+                 << "(" << c << ", " << static_cast<const void*>(width) << ", "
+                 << static_cast<const void*>(height) << ", "
+                 << static_cast<const void*>(bytesPerValue) << ", " << buffer
+                 << ")");
+  GLboolean result = osmesa_api_->OSMesaGetDepthBufferFn(c, width, height,
+                                                         bytesPerValue, buffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugOSMESAApi::OSMesaGetIntegervFn(GLint pname, GLint* value) {
+  GL_SERVICE_LOG("OSMesaGetIntegerv"
+                 << "(" << pname << ", " << static_cast<const void*>(value)
+                 << ")");
+  osmesa_api_->OSMesaGetIntegervFn(pname, value);
+}
+
+OSMESAproc DebugOSMESAApi::OSMesaGetProcAddressFn(const char* funcName) {
+  GL_SERVICE_LOG("OSMesaGetProcAddress"
+                 << "(" << funcName << ")");
+  OSMESAproc result = osmesa_api_->OSMesaGetProcAddressFn(funcName);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+GLboolean DebugOSMESAApi::OSMesaMakeCurrentFn(OSMesaContext ctx,
+                                              void* buffer,
+                                              GLenum type,
+                                              GLsizei width,
+                                              GLsizei height) {
+  GL_SERVICE_LOG("OSMesaMakeCurrent"
+                 << "(" << ctx << ", " << static_cast<const void*>(buffer)
+                 << ", " << GLEnums::GetStringEnum(type) << ", " << width
+                 << ", " << height << ")");
+  GLboolean result =
+      osmesa_api_->OSMesaMakeCurrentFn(ctx, buffer, type, width, height);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+void DebugOSMESAApi::OSMesaPixelStoreFn(GLint pname, GLint value) {
+  GL_SERVICE_LOG("OSMesaPixelStore"
+                 << "(" << pname << ", " << value << ")");
+  osmesa_api_->OSMesaPixelStoreFn(pname, value);
+}
+
 }  // namespace gl
diff --git a/chromium/ui/gl/gl_bindings_autogen_wgl.cc b/chromium/ui/gl/gl_bindings_autogen_wgl.cc
index c66533f2a22..465f13a2986 100644
--- a/chromium/ui/gl/gl_bindings_autogen_wgl.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_wgl.cc
@@ -20,7 +20,6 @@
 
 namespace gl {
 
-static bool g_debugBindingsInitialized;
 DriverWGL g_driver_wgl;
 
 void DriverWGL::InitializeStaticBindings() {
@@ -76,350 +75,47 @@ void DriverWGL::InitializeExtensionBindings() {
   ext.b_WGL_EXT_swap_control =
       extensions.find("WGL_EXT_swap_control ") != std::string::npos;
 
-  debug_fn.wglChoosePixelFormatARBFn = 0;
   if (ext.b_WGL_ARB_pixel_format) {
     fn.wglChoosePixelFormatARBFn =
         reinterpret_cast<wglChoosePixelFormatARBProc>(
             GetGLProcAddress("wglChoosePixelFormatARB"));
   }
 
-  debug_fn.wglCreateContextAttribsARBFn = 0;
   if (ext.b_WGL_ARB_create_context) {
     fn.wglCreateContextAttribsARBFn =
         reinterpret_cast<wglCreateContextAttribsARBProc>(
             GetGLProcAddress("wglCreateContextAttribsARB"));
   }
 
-  debug_fn.wglCreatePbufferARBFn = 0;
   if (ext.b_WGL_ARB_pbuffer) {
     fn.wglCreatePbufferARBFn = reinterpret_cast<wglCreatePbufferARBProc>(
         GetGLProcAddress("wglCreatePbufferARB"));
   }
 
-  debug_fn.wglDestroyPbufferARBFn = 0;
   if (ext.b_WGL_ARB_pbuffer) {
     fn.wglDestroyPbufferARBFn = reinterpret_cast<wglDestroyPbufferARBProc>(
         GetGLProcAddress("wglDestroyPbufferARB"));
   }
 
-  debug_fn.wglGetPbufferDCARBFn = 0;
   if (ext.b_WGL_ARB_pbuffer) {
     fn.wglGetPbufferDCARBFn = reinterpret_cast<wglGetPbufferDCARBProc>(
         GetGLProcAddress("wglGetPbufferDCARB"));
   }
 
-  debug_fn.wglQueryPbufferARBFn = 0;
   if (ext.b_WGL_ARB_pbuffer) {
     fn.wglQueryPbufferARBFn = reinterpret_cast<wglQueryPbufferARBProc>(
         GetGLProcAddress("wglQueryPbufferARB"));
   }
 
-  debug_fn.wglReleasePbufferDCARBFn = 0;
   if (ext.b_WGL_ARB_pbuffer) {
     fn.wglReleasePbufferDCARBFn = reinterpret_cast<wglReleasePbufferDCARBProc>(
         GetGLProcAddress("wglReleasePbufferDCARB"));
   }
 
-  debug_fn.wglSwapIntervalEXTFn = 0;
   if (ext.b_WGL_EXT_swap_control) {
     fn.wglSwapIntervalEXTFn = reinterpret_cast<wglSwapIntervalEXTProc>(
         GetGLProcAddress("wglSwapIntervalEXT"));
   }
-
-  if (g_debugBindingsInitialized)
-    InitializeDebugBindings();
-}
-
-extern "C" {
-
-static BOOL GL_BINDING_CALL
-Debug_wglChoosePixelFormatARB(HDC dc,
-                              const int* int_attrib_list,
-                              const float* float_attrib_list,
-                              UINT max_formats,
-                              int* formats,
-                              UINT* num_formats) {
-  GL_SERVICE_LOG("wglChoosePixelFormatARB"
-                 << "(" << dc << ", "
-                 << static_cast<const void*>(int_attrib_list) << ", "
-                 << static_cast<const void*>(float_attrib_list) << ", "
-                 << max_formats << ", " << static_cast<const void*>(formats)
-                 << ", " << static_cast<const void*>(num_formats) << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglChoosePixelFormatARBFn != nullptr);
-  BOOL result = g_driver_wgl.debug_fn.wglChoosePixelFormatARBFn(
-      dc, int_attrib_list, float_attrib_list, max_formats, formats,
-      num_formats);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static BOOL GL_BINDING_CALL Debug_wglCopyContext(HGLRC hglrcSrc,
-                                                 HGLRC hglrcDst,
-                                                 UINT mask) {
-  GL_SERVICE_LOG("wglCopyContext"
-                 << "(" << hglrcSrc << ", " << hglrcDst << ", " << mask << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglCopyContextFn != nullptr);
-  BOOL result =
-      g_driver_wgl.debug_fn.wglCopyContextFn(hglrcSrc, hglrcDst, mask);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static HGLRC GL_BINDING_CALL Debug_wglCreateContext(HDC hdc) {
-  GL_SERVICE_LOG("wglCreateContext"
-                 << "(" << hdc << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglCreateContextFn != nullptr);
-  HGLRC result = g_driver_wgl.debug_fn.wglCreateContextFn(hdc);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static HGLRC GL_BINDING_CALL
-Debug_wglCreateContextAttribsARB(HDC hDC,
-                                 HGLRC hShareContext,
-                                 const int* attribList) {
-  GL_SERVICE_LOG("wglCreateContextAttribsARB"
-                 << "(" << hDC << ", " << hShareContext << ", "
-                 << static_cast<const void*>(attribList) << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglCreateContextAttribsARBFn != nullptr);
-  HGLRC result = g_driver_wgl.debug_fn.wglCreateContextAttribsARBFn(
-      hDC, hShareContext, attribList);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static HGLRC GL_BINDING_CALL Debug_wglCreateLayerContext(HDC hdc,
-                                                         int iLayerPlane) {
-  GL_SERVICE_LOG("wglCreateLayerContext"
-                 << "(" << hdc << ", " << iLayerPlane << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglCreateLayerContextFn != nullptr);
-  HGLRC result =
-      g_driver_wgl.debug_fn.wglCreateLayerContextFn(hdc, iLayerPlane);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static HPBUFFERARB GL_BINDING_CALL
-Debug_wglCreatePbufferARB(HDC hDC,
-                          int iPixelFormat,
-                          int iWidth,
-                          int iHeight,
-                          const int* piAttribList) {
-  GL_SERVICE_LOG("wglCreatePbufferARB"
-                 << "(" << hDC << ", " << iPixelFormat << ", " << iWidth << ", "
-                 << iHeight << ", " << static_cast<const void*>(piAttribList)
-                 << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglCreatePbufferARBFn != nullptr);
-  HPBUFFERARB result = g_driver_wgl.debug_fn.wglCreatePbufferARBFn(
-      hDC, iPixelFormat, iWidth, iHeight, piAttribList);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static BOOL GL_BINDING_CALL Debug_wglDeleteContext(HGLRC hglrc) {
-  GL_SERVICE_LOG("wglDeleteContext"
-                 << "(" << hglrc << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglDeleteContextFn != nullptr);
-  BOOL result = g_driver_wgl.debug_fn.wglDeleteContextFn(hglrc);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static BOOL GL_BINDING_CALL Debug_wglDestroyPbufferARB(HPBUFFERARB hPbuffer) {
-  GL_SERVICE_LOG("wglDestroyPbufferARB"
-                 << "(" << hPbuffer << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglDestroyPbufferARBFn != nullptr);
-  BOOL result = g_driver_wgl.debug_fn.wglDestroyPbufferARBFn(hPbuffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static HGLRC GL_BINDING_CALL Debug_wglGetCurrentContext() {
-  GL_SERVICE_LOG("wglGetCurrentContext"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglGetCurrentContextFn != nullptr);
-  HGLRC result = g_driver_wgl.debug_fn.wglGetCurrentContextFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static HDC GL_BINDING_CALL Debug_wglGetCurrentDC() {
-  GL_SERVICE_LOG("wglGetCurrentDC"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglGetCurrentDCFn != nullptr);
-  HDC result = g_driver_wgl.debug_fn.wglGetCurrentDCFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static const char* GL_BINDING_CALL Debug_wglGetExtensionsStringARB(HDC hDC) {
-  GL_SERVICE_LOG("wglGetExtensionsStringARB"
-                 << "(" << hDC << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglGetExtensionsStringARBFn != nullptr);
-  const char* result = g_driver_wgl.debug_fn.wglGetExtensionsStringARBFn(hDC);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static const char* GL_BINDING_CALL Debug_wglGetExtensionsStringEXT() {
-  GL_SERVICE_LOG("wglGetExtensionsStringEXT"
-                 << "("
-                 << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglGetExtensionsStringEXTFn != nullptr);
-  const char* result = g_driver_wgl.debug_fn.wglGetExtensionsStringEXTFn();
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static HDC GL_BINDING_CALL Debug_wglGetPbufferDCARB(HPBUFFERARB hPbuffer) {
-  GL_SERVICE_LOG("wglGetPbufferDCARB"
-                 << "(" << hPbuffer << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglGetPbufferDCARBFn != nullptr);
-  HDC result = g_driver_wgl.debug_fn.wglGetPbufferDCARBFn(hPbuffer);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static BOOL GL_BINDING_CALL Debug_wglMakeCurrent(HDC hdc, HGLRC hglrc) {
-  GL_SERVICE_LOG("wglMakeCurrent"
-                 << "(" << hdc << ", " << hglrc << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglMakeCurrentFn != nullptr);
-  BOOL result = g_driver_wgl.debug_fn.wglMakeCurrentFn(hdc, hglrc);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static BOOL GL_BINDING_CALL Debug_wglQueryPbufferARB(HPBUFFERARB hPbuffer,
-                                                     int iAttribute,
-                                                     int* piValue) {
-  GL_SERVICE_LOG("wglQueryPbufferARB"
-                 << "(" << hPbuffer << ", " << iAttribute << ", "
-                 << static_cast<const void*>(piValue) << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglQueryPbufferARBFn != nullptr);
-  BOOL result =
-      g_driver_wgl.debug_fn.wglQueryPbufferARBFn(hPbuffer, iAttribute, piValue);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static int GL_BINDING_CALL Debug_wglReleasePbufferDCARB(HPBUFFERARB hPbuffer,
-                                                        HDC hDC) {
-  GL_SERVICE_LOG("wglReleasePbufferDCARB"
-                 << "(" << hPbuffer << ", " << hDC << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglReleasePbufferDCARBFn != nullptr);
-  int result = g_driver_wgl.debug_fn.wglReleasePbufferDCARBFn(hPbuffer, hDC);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static BOOL GL_BINDING_CALL Debug_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
-  GL_SERVICE_LOG("wglShareLists"
-                 << "(" << hglrc1 << ", " << hglrc2 << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglShareListsFn != nullptr);
-  BOOL result = g_driver_wgl.debug_fn.wglShareListsFn(hglrc1, hglrc2);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static BOOL GL_BINDING_CALL Debug_wglSwapIntervalEXT(int interval) {
-  GL_SERVICE_LOG("wglSwapIntervalEXT"
-                 << "(" << interval << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglSwapIntervalEXTFn != nullptr);
-  BOOL result = g_driver_wgl.debug_fn.wglSwapIntervalEXTFn(interval);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-
-static BOOL GL_BINDING_CALL Debug_wglSwapLayerBuffers(HDC hdc, UINT fuPlanes) {
-  GL_SERVICE_LOG("wglSwapLayerBuffers"
-                 << "(" << hdc << ", " << fuPlanes << ")");
-  DCHECK(g_driver_wgl.debug_fn.wglSwapLayerBuffersFn != nullptr);
-  BOOL result = g_driver_wgl.debug_fn.wglSwapLayerBuffersFn(hdc, fuPlanes);
-  GL_SERVICE_LOG("GL_RESULT: " << result);
-  return result;
-}
-}  // extern "C"
-
-void DriverWGL::InitializeDebugBindings() {
-  if (!debug_fn.wglChoosePixelFormatARBFn) {
-    debug_fn.wglChoosePixelFormatARBFn = fn.wglChoosePixelFormatARBFn;
-    fn.wglChoosePixelFormatARBFn = Debug_wglChoosePixelFormatARB;
-  }
-  if (!debug_fn.wglCopyContextFn) {
-    debug_fn.wglCopyContextFn = fn.wglCopyContextFn;
-    fn.wglCopyContextFn = Debug_wglCopyContext;
-  }
-  if (!debug_fn.wglCreateContextFn) {
-    debug_fn.wglCreateContextFn = fn.wglCreateContextFn;
-    fn.wglCreateContextFn = Debug_wglCreateContext;
-  }
-  if (!debug_fn.wglCreateContextAttribsARBFn) {
-    debug_fn.wglCreateContextAttribsARBFn = fn.wglCreateContextAttribsARBFn;
-    fn.wglCreateContextAttribsARBFn = Debug_wglCreateContextAttribsARB;
-  }
-  if (!debug_fn.wglCreateLayerContextFn) {
-    debug_fn.wglCreateLayerContextFn = fn.wglCreateLayerContextFn;
-    fn.wglCreateLayerContextFn = Debug_wglCreateLayerContext;
-  }
-  if (!debug_fn.wglCreatePbufferARBFn) {
-    debug_fn.wglCreatePbufferARBFn = fn.wglCreatePbufferARBFn;
-    fn.wglCreatePbufferARBFn = Debug_wglCreatePbufferARB;
-  }
-  if (!debug_fn.wglDeleteContextFn) {
-    debug_fn.wglDeleteContextFn = fn.wglDeleteContextFn;
-    fn.wglDeleteContextFn = Debug_wglDeleteContext;
-  }
-  if (!debug_fn.wglDestroyPbufferARBFn) {
-    debug_fn.wglDestroyPbufferARBFn = fn.wglDestroyPbufferARBFn;
-    fn.wglDestroyPbufferARBFn = Debug_wglDestroyPbufferARB;
-  }
-  if (!debug_fn.wglGetCurrentContextFn) {
-    debug_fn.wglGetCurrentContextFn = fn.wglGetCurrentContextFn;
-    fn.wglGetCurrentContextFn = Debug_wglGetCurrentContext;
-  }
-  if (!debug_fn.wglGetCurrentDCFn) {
-    debug_fn.wglGetCurrentDCFn = fn.wglGetCurrentDCFn;
-    fn.wglGetCurrentDCFn = Debug_wglGetCurrentDC;
-  }
-  if (!debug_fn.wglGetExtensionsStringARBFn) {
-    debug_fn.wglGetExtensionsStringARBFn = fn.wglGetExtensionsStringARBFn;
-    fn.wglGetExtensionsStringARBFn = Debug_wglGetExtensionsStringARB;
-  }
-  if (!debug_fn.wglGetExtensionsStringEXTFn) {
-    debug_fn.wglGetExtensionsStringEXTFn = fn.wglGetExtensionsStringEXTFn;
-    fn.wglGetExtensionsStringEXTFn = Debug_wglGetExtensionsStringEXT;
-  }
-  if (!debug_fn.wglGetPbufferDCARBFn) {
-    debug_fn.wglGetPbufferDCARBFn = fn.wglGetPbufferDCARBFn;
-    fn.wglGetPbufferDCARBFn = Debug_wglGetPbufferDCARB;
-  }
-  if (!debug_fn.wglMakeCurrentFn) {
-    debug_fn.wglMakeCurrentFn = fn.wglMakeCurrentFn;
-    fn.wglMakeCurrentFn = Debug_wglMakeCurrent;
-  }
-  if (!debug_fn.wglQueryPbufferARBFn) {
-    debug_fn.wglQueryPbufferARBFn = fn.wglQueryPbufferARBFn;
-    fn.wglQueryPbufferARBFn = Debug_wglQueryPbufferARB;
-  }
-  if (!debug_fn.wglReleasePbufferDCARBFn) {
-    debug_fn.wglReleasePbufferDCARBFn = fn.wglReleasePbufferDCARBFn;
-    fn.wglReleasePbufferDCARBFn = Debug_wglReleasePbufferDCARB;
-  }
-  if (!debug_fn.wglShareListsFn) {
-    debug_fn.wglShareListsFn = fn.wglShareListsFn;
-    fn.wglShareListsFn = Debug_wglShareLists;
-  }
-  if (!debug_fn.wglSwapIntervalEXTFn) {
-    debug_fn.wglSwapIntervalEXTFn = fn.wglSwapIntervalEXTFn;
-    fn.wglSwapIntervalEXTFn = Debug_wglSwapIntervalEXT;
-  }
-  if (!debug_fn.wglSwapLayerBuffersFn) {
-    debug_fn.wglSwapLayerBuffersFn = fn.wglSwapLayerBuffersFn;
-    fn.wglSwapLayerBuffersFn = Debug_wglSwapLayerBuffers;
-  }
-  g_debugBindingsInitialized = true;
 }
 
 void DriverWGL::ClearBindings() {
@@ -630,4 +326,184 @@ BOOL TraceWGLApi::wglSwapLayerBuffersFn(HDC hdc, UINT fuPlanes) {
   return wgl_api_->wglSwapLayerBuffersFn(hdc, fuPlanes);
 }
 
+BOOL DebugWGLApi::wglChoosePixelFormatARBFn(HDC dc,
+                                            const int* int_attrib_list,
+                                            const float* float_attrib_list,
+                                            UINT max_formats,
+                                            int* formats,
+                                            UINT* num_formats) {
+  GL_SERVICE_LOG("wglChoosePixelFormatARB"
+                 << "(" << dc << ", "
+                 << static_cast<const void*>(int_attrib_list) << ", "
+                 << static_cast<const void*>(float_attrib_list) << ", "
+                 << max_formats << ", " << static_cast<const void*>(formats)
+                 << ", " << static_cast<const void*>(num_formats) << ")");
+  BOOL result = wgl_api_->wglChoosePixelFormatARBFn(
+      dc, int_attrib_list, float_attrib_list, max_formats, formats,
+      num_formats);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+BOOL DebugWGLApi::wglCopyContextFn(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask) {
+  GL_SERVICE_LOG("wglCopyContext"
+                 << "(" << hglrcSrc << ", " << hglrcDst << ", " << mask << ")");
+  BOOL result = wgl_api_->wglCopyContextFn(hglrcSrc, hglrcDst, mask);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+HGLRC DebugWGLApi::wglCreateContextFn(HDC hdc) {
+  GL_SERVICE_LOG("wglCreateContext"
+                 << "(" << hdc << ")");
+  HGLRC result = wgl_api_->wglCreateContextFn(hdc);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+HGLRC DebugWGLApi::wglCreateContextAttribsARBFn(HDC hDC,
+                                                HGLRC hShareContext,
+                                                const int* attribList) {
+  GL_SERVICE_LOG("wglCreateContextAttribsARB"
+                 << "(" << hDC << ", " << hShareContext << ", "
+                 << static_cast<const void*>(attribList) << ")");
+  HGLRC result =
+      wgl_api_->wglCreateContextAttribsARBFn(hDC, hShareContext, attribList);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+HGLRC DebugWGLApi::wglCreateLayerContextFn(HDC hdc, int iLayerPlane) {
+  GL_SERVICE_LOG("wglCreateLayerContext"
+                 << "(" << hdc << ", " << iLayerPlane << ")");
+  HGLRC result = wgl_api_->wglCreateLayerContextFn(hdc, iLayerPlane);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+HPBUFFERARB DebugWGLApi::wglCreatePbufferARBFn(HDC hDC,
+                                               int iPixelFormat,
+                                               int iWidth,
+                                               int iHeight,
+                                               const int* piAttribList) {
+  GL_SERVICE_LOG("wglCreatePbufferARB"
+                 << "(" << hDC << ", " << iPixelFormat << ", " << iWidth << ", "
+                 << iHeight << ", " << static_cast<const void*>(piAttribList)
+                 << ")");
+  HPBUFFERARB result = wgl_api_->wglCreatePbufferARBFn(
+      hDC, iPixelFormat, iWidth, iHeight, piAttribList);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+BOOL DebugWGLApi::wglDeleteContextFn(HGLRC hglrc) {
+  GL_SERVICE_LOG("wglDeleteContext"
+                 << "(" << hglrc << ")");
+  BOOL result = wgl_api_->wglDeleteContextFn(hglrc);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+BOOL DebugWGLApi::wglDestroyPbufferARBFn(HPBUFFERARB hPbuffer) {
+  GL_SERVICE_LOG("wglDestroyPbufferARB"
+                 << "(" << hPbuffer << ")");
+  BOOL result = wgl_api_->wglDestroyPbufferARBFn(hPbuffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+HGLRC DebugWGLApi::wglGetCurrentContextFn() {
+  GL_SERVICE_LOG("wglGetCurrentContext"
+                 << "("
+                 << ")");
+  HGLRC result = wgl_api_->wglGetCurrentContextFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+HDC DebugWGLApi::wglGetCurrentDCFn() {
+  GL_SERVICE_LOG("wglGetCurrentDC"
+                 << "("
+                 << ")");
+  HDC result = wgl_api_->wglGetCurrentDCFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+const char* DebugWGLApi::wglGetExtensionsStringARBFn(HDC hDC) {
+  GL_SERVICE_LOG("wglGetExtensionsStringARB"
+                 << "(" << hDC << ")");
+  const char* result = wgl_api_->wglGetExtensionsStringARBFn(hDC);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+const char* DebugWGLApi::wglGetExtensionsStringEXTFn() {
+  GL_SERVICE_LOG("wglGetExtensionsStringEXT"
+                 << "("
+                 << ")");
+  const char* result = wgl_api_->wglGetExtensionsStringEXTFn();
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+HDC DebugWGLApi::wglGetPbufferDCARBFn(HPBUFFERARB hPbuffer) {
+  GL_SERVICE_LOG("wglGetPbufferDCARB"
+                 << "(" << hPbuffer << ")");
+  HDC result = wgl_api_->wglGetPbufferDCARBFn(hPbuffer);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+BOOL DebugWGLApi::wglMakeCurrentFn(HDC hdc, HGLRC hglrc) {
+  GL_SERVICE_LOG("wglMakeCurrent"
+                 << "(" << hdc << ", " << hglrc << ")");
+  BOOL result = wgl_api_->wglMakeCurrentFn(hdc, hglrc);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+BOOL DebugWGLApi::wglQueryPbufferARBFn(HPBUFFERARB hPbuffer,
+                                       int iAttribute,
+                                       int* piValue) {
+  GL_SERVICE_LOG("wglQueryPbufferARB"
+                 << "(" << hPbuffer << ", " << iAttribute << ", "
+                 << static_cast<const void*>(piValue) << ")");
+  BOOL result = wgl_api_->wglQueryPbufferARBFn(hPbuffer, iAttribute, piValue);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+int DebugWGLApi::wglReleasePbufferDCARBFn(HPBUFFERARB hPbuffer, HDC hDC) {
+  GL_SERVICE_LOG("wglReleasePbufferDCARB"
+                 << "(" << hPbuffer << ", " << hDC << ")");
+  int result = wgl_api_->wglReleasePbufferDCARBFn(hPbuffer, hDC);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+BOOL DebugWGLApi::wglShareListsFn(HGLRC hglrc1, HGLRC hglrc2) {
+  GL_SERVICE_LOG("wglShareLists"
+                 << "(" << hglrc1 << ", " << hglrc2 << ")");
+  BOOL result = wgl_api_->wglShareListsFn(hglrc1, hglrc2);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+BOOL DebugWGLApi::wglSwapIntervalEXTFn(int interval) {
+  GL_SERVICE_LOG("wglSwapIntervalEXT"
+                 << "(" << interval << ")");
+  BOOL result = wgl_api_->wglSwapIntervalEXTFn(interval);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+BOOL DebugWGLApi::wglSwapLayerBuffersFn(HDC hdc, UINT fuPlanes) {
+  GL_SERVICE_LOG("wglSwapLayerBuffers"
+                 << "(" << hdc << ", " << fuPlanes << ")");
+  BOOL result = wgl_api_->wglSwapLayerBuffersFn(hdc, fuPlanes);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 }  // namespace gl
diff --git a/chromium/ui/gl/gl_context.cc b/chromium/ui/gl/gl_context.cc
index 609d131f03c..56591dcbebb 100644
--- a/chromium/ui/gl/gl_context.cc
+++ b/chromium/ui/gl/gl_context.cc
@@ -45,7 +45,9 @@ void GLContext::ScopedReleaseCurrent::Cancel() {
 }
 
 GLContext::GLContext(GLShareGroup* share_group)
-    : share_group_(share_group),
+    : static_bindings_initialized_(false),
+      dynamic_bindings_initialized_(false),
+      share_group_(share_group),
       current_virtual_context_(nullptr),
       state_dirtied_externally_(false),
       swap_interval_(1),
@@ -60,9 +62,16 @@ GLContext::~GLContext() {
   share_group_->RemoveContext(this);
   if (GetCurrent() == this) {
     SetCurrent(nullptr);
+    SetCurrentGL(nullptr);
   }
 }
 
+GLApi* GLContext::CreateGLApi(DriverGL* driver) {
+  real_gl_api_ = new RealGLApi;
+  real_gl_api_->Initialize(driver);
+  return real_gl_api_;
+}
+
 void GLContext::SetSafeToForceGpuSwitch() {
 }
 
@@ -76,20 +85,22 @@ void GLContext::SetUnbindFboOnMakeCurrent() {
 
 std::string GLContext::GetExtensions() {
   DCHECK(IsCurrent(nullptr));
-  return GetGLExtensionsFromCurrentContext();
+  return GetGLExtensionsFromCurrentContext(gl_api_.get());
 }
 
 std::string GLContext::GetGLVersion() {
   DCHECK(IsCurrent(nullptr));
-  const char *version =
-      reinterpret_cast<const char*>(glGetString(GL_VERSION));
+  DCHECK(gl_api_ != nullptr);
+  const char* version =
+      reinterpret_cast<const char*>(gl_api_->glGetStringFn(GL_VERSION));
   return std::string(version ? version : "");
 }
 
 std::string GLContext::GetGLRenderer() {
   DCHECK(IsCurrent(nullptr));
-  const char *renderer =
-      reinterpret_cast<const char*>(glGetString(GL_RENDERER));
+  DCHECK(gl_api_ != nullptr);
+  const char* renderer =
+      reinterpret_cast<const char*>(gl_api_->glGetStringFn(GL_RENDERER));
   return std::string(renderer ? renderer : "");
 }
 
@@ -97,6 +108,36 @@ YUVToRGBConverter* GLContext::GetYUVToRGBConverter() {
   return nullptr;
 }
 
+CurrentGL* GLContext::GetCurrentGL() {
+  if (!static_bindings_initialized_) {
+    driver_gl_.reset(new DriverGL);
+    driver_gl_->InitializeStaticBindings();
+
+    gl_api_.reset(CreateGLApi(driver_gl_.get()));
+    GLApi* final_api = gl_api_.get();
+
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableGPUServiceTracing)) {
+      trace_gl_api_.reset(new TraceGLApi(final_api));
+      final_api = trace_gl_api_.get();
+    }
+
+    if (GetDebugGLBindingsInitializedGL()) {
+      debug_gl_api_.reset(new DebugGLApi(final_api));
+      final_api = debug_gl_api_.get();
+    }
+
+    current_gl_.reset(new CurrentGL);
+    current_gl_->Driver = driver_gl_.get();
+    current_gl_->Api = final_api;
+    current_gl_->Version = version_info_.get();
+
+    static_bindings_initialized_ = true;
+  }
+
+  return current_gl_.get();
+}
+
 bool GLContext::HasExtension(const char* name) {
   std::string extensions = GetExtensions();
   extensions += " ";
@@ -109,10 +150,12 @@ bool GLContext::HasExtension(const char* name) {
 
 const GLVersionInfo* GLContext::GetVersionInfo() {
   if (!version_info_) {
-    std::string version = GetGLVersion();
-    std::string renderer = GetGLRenderer();
-    version_info_ = base::MakeUnique<GLVersionInfo>(
-        version.c_str(), renderer.c_str(), GetExtensions().c_str());
+    version_info_ = GenerateGLVersionInfo();
+
+    // current_gl_ may be null for virtual contexts
+    if (current_gl_) {
+      current_gl_->Version = version_info_.get();
+    }
   }
   return version_info_.get();
 }
@@ -126,11 +169,13 @@ bool GLContext::LosesAllContextsOnContextLost() {
     case kGLImplementationDesktopGL:
       return false;
     case kGLImplementationEGLGLES2:
+    case kGLImplementationSwiftShaderGL:
       return true;
     case kGLImplementationOSMesaGL:
     case kGLImplementationAppleGL:
       return false;
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return false;
     default:
       NOTREACHED();
@@ -146,14 +191,20 @@ GLContext* GLContext::GetRealCurrent() {
   return current_real_context_.Pointer()->Get();
 }
 
+std::unique_ptr<gl::GLVersionInfo> GLContext::GenerateGLVersionInfo() {
+  return base::MakeUnique<GLVersionInfo>(
+      GetGLVersion().c_str(), GetGLRenderer().c_str(), GetExtensions().c_str());
+}
+
 void GLContext::SetCurrent(GLSurface* surface) {
   current_context_.Pointer()->Set(surface ? this : nullptr);
   GLSurface::SetCurrent(surface);
   // Leave the real GL api current so that unit tests work correctly.
   // TODO(sievers): Remove this, but needs all gpu_unittest classes
   // to create and make current a context.
-  if (!surface && GetGLImplementation() != kGLImplementationMockGL) {
-    SetGLApiToNoContext();
+  if (!surface && GetGLImplementation() != kGLImplementationMockGL &&
+      GetGLImplementation() != kGLImplementationStubGL) {
+    SetCurrentGL(nullptr);
   }
 }
 
@@ -181,7 +232,16 @@ bool GLContext::WasAllocatedUsingRobustnessExtension() {
 
 void GLContext::InitializeDynamicBindings() {
   DCHECK(IsCurrent(nullptr));
-  InitializeDynamicGLBindingsGL(this);
+  DCHECK(static_bindings_initialized_);
+  if (!dynamic_bindings_initialized_) {
+    if (real_gl_api_) {
+      real_gl_api_->InitializeFilteredExtensions();
+      real_gl_api_->set_version(GenerateGLVersionInfo());
+    }
+
+    driver_gl_->InitializeDynamicBindings(GetVersionInfo(), GetExtensions());
+    dynamic_bindings_initialized_ = true;
+  }
 }
 
 bool GLContext::MakeVirtuallyCurrent(
@@ -247,8 +307,8 @@ void GLContext::OnReleaseVirtuallyCurrent(GLContext* virtual_context) {
     current_virtual_context_ = nullptr;
 }
 
-void GLContext::SetRealGLApi() {
-  SetGLToRealGLApi();
+void GLContext::BindGLApi() {
+  SetCurrentGL(GetCurrentGL());
 }
 
 GLContextReal::GLContextReal(GLShareGroup* share_group)
diff --git a/chromium/ui/gl/gl_context.h b/chromium/ui/gl/gl_context.h
index 542940c7683..ecb9345e0bc 100644
--- a/chromium/ui/gl/gl_context.h
+++ b/chromium/ui/gl/gl_context.h
@@ -28,15 +28,24 @@ class GLContextVirtual;
 
 namespace gl {
 
+struct CurrentGL;
+class DebugGLApi;
+struct DriverGL;
+class GLApi;
 class GLSurface;
 class GPUTiming;
 class GPUTimingClient;
 struct GLVersionInfo;
+class RealGLApi;
+class TraceGLApi;
 
 struct GLContextAttribs {
   GpuPreference gpu_preference = PreferIntegratedGpu;
   bool bind_generates_resource = true;
   bool webgl_compatibility_context = false;
+  bool global_texture_share_group = false;
+  int client_major_es_version = 3;
+  int client_minor_es_version = 0;
 };
 
 // Encapsulates an OpenGL context, hiding platform specific management.
@@ -137,9 +146,17 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
   // Returns a helper structure to convert YUV textures to RGB textures.
   virtual YUVToRGBConverter* GetYUVToRGBConverter();
 
+  // Get the CurrentGL object for this context containing the driver, version
+  // and API.
+  CurrentGL* GetCurrentGL();
+
  protected:
   virtual ~GLContext();
 
+  // Create the GLApi for this context using the provided driver. Creates a
+  // RealGLApi by default.
+  virtual GLApi* CreateGLApi(DriverGL* driver);
+
   // Will release the current context when going out of scope, unless canceled.
   class ScopedReleaseCurrent {
    public:
@@ -153,7 +170,7 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
   };
 
   // Sets the GL api to the real hardware API (vs the VirtualAPI)
-  static void SetRealGLApi();
+  void BindGLApi();
   virtual void SetCurrent(GLSurface* surface);
 
   // Initialize function pointers to functions where the bound version depends
@@ -172,6 +189,19 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
   // For GetRealCurrent.
   friend class gpu::GLContextVirtual;
 
+  std::unique_ptr<GLVersionInfo> GenerateGLVersionInfo();
+
+  bool static_bindings_initialized_;
+  bool dynamic_bindings_initialized_;
+  std::unique_ptr<DriverGL> driver_gl_;
+  std::unique_ptr<GLApi> gl_api_;
+  std::unique_ptr<TraceGLApi> trace_gl_api_;
+  std::unique_ptr<DebugGLApi> debug_gl_api_;
+  std::unique_ptr<CurrentGL> current_gl_;
+
+  // Copy of the real API (if one was created) for dynamic initialization
+  RealGLApi* real_gl_api_ = nullptr;
+
   scoped_refptr<GLShareGroup> share_group_;
   GLContext* current_virtual_context_;
   bool state_dirtied_externally_;
diff --git a/chromium/ui/gl/gl_context_cgl.cc b/chromium/ui/gl/gl_context_cgl.cc
index 2a105c4983d..06e5e73b93a 100644
--- a/chromium/ui/gl/gl_context_cgl.cc
+++ b/chromium/ui/gl/gl_context_cgl.cc
@@ -17,6 +17,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gpu_switching_manager.h"
@@ -149,8 +150,20 @@ bool GLContextCGL::Initialize(GLSurface* compatible_surface,
 
 void GLContextCGL::Destroy() {
   if (yuv_to_rgb_converter_) {
+    // If this context is not current, bind this context's API so that the YUV
+    // converter can safely destruct
+    GLContext* current_context = GetRealCurrent();
+    if (current_context != this) {
+      SetCurrentGL(GetCurrentGL());
+    }
+
     ScopedCGLSetCurrentContext(static_cast<CGLContextObj>(context_));
     yuv_to_rgb_converter_.reset();
+
+    // Rebind the current context's API if needed.
+    if (current_context && current_context != this) {
+      SetCurrentGL(current_context->GetCurrentGL());
+    }
   }
   if (discrete_pixelformat_) {
     if (base::MessageLoop::current() != nullptr) {
@@ -236,7 +249,7 @@ bool GLContextCGL::MakeCurrent(GLSurface* surface) {
   }
 
   // Set this as soon as the context is current, since we might call into GL.
-  SetRealGLApi();
+  BindGLApi();
 
   SetCurrent(surface);
   InitializeDynamicBindings();
diff --git a/chromium/ui/gl/gl_context_egl.cc b/chromium/ui/gl/gl_context_egl.cc
index 1cd08cd4049..4642b702885 100644
--- a/chromium/ui/gl/gl_context_egl.cc
+++ b/chromium/ui/gl/gl_context_egl.cc
@@ -32,6 +32,16 @@ extern "C" {
 #define EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE 0x3AAC
 #endif /* EGL_ANGLE_create_context_webgl_compatibility */
 
+#ifndef EGL_ANGLE_display_texture_share_group
+#define EGL_ANGLE_display_texture_share_group 1
+#define EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE 0x3AAF
+#endif /* EGL_ANGLE_display_texture_share_group */
+
+#ifndef EGL_ANGLE_create_context_client_arrays
+#define EGL_ANGLE_create_context_client_arrays 1
+#define EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE 0x3452
+#endif /* EGL_ANGLE_create_context_client_arrays */
+
 using ui::GetLastEGLErrorString;
 
 namespace gl {
@@ -61,16 +71,36 @@ bool GLContextEGL::Initialize(GLSurface* compatible_surface,
     return false;
   }
 
-  EGLint context_client_version = 2;
-  if ((config_renderable_type & EGL_OPENGL_ES3_BIT) != 0 &&
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableES3GLContext)) {
-    context_client_version = 3;
+  EGLint context_client_major_version = attribs.client_major_es_version;
+  EGLint context_client_minor_version = attribs.client_minor_es_version;
+
+  // If the requested context is ES3 but the config cannot support ES3, request
+  // ES2 instead.
+  if ((config_renderable_type & EGL_OPENGL_ES3_BIT) == 0 &&
+      context_client_major_version >= 3) {
+    context_client_major_version = 2;
+    context_client_minor_version = 0;
   }
 
   std::vector<EGLint> context_attributes;
-  context_attributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
-  context_attributes.push_back(context_client_version);
+
+  // EGL_KHR_create_context allows requesting both a major and minor context
+  // version
+  if (GLSurfaceEGL::HasEGLExtension("EGL_KHR_create_context")) {
+    context_attributes.push_back(EGL_CONTEXT_MAJOR_VERSION);
+    context_attributes.push_back(context_client_major_version);
+
+    context_attributes.push_back(EGL_CONTEXT_MINOR_VERSION);
+    context_attributes.push_back(context_client_minor_version);
+  } else {
+    context_attributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
+    context_attributes.push_back(context_client_major_version);
+
+    // Can only request 2.0 or 3.0 contexts without the EGL_KHR_create_context
+    // extension, DCHECK to make sure we update the code to support devices
+    // without this extension
+    DCHECK(context_client_minor_version == 0);
+  }
 
   if (GLSurfaceEGL::IsCreateContextRobustnessSupported()) {
     DVLOG(1) << "EGL_EXT_create_context_robustness supported.";
@@ -105,6 +135,20 @@ bool GLContextEGL::Initialize(GLSurface* compatible_surface,
     DCHECK(!attribs.webgl_compatibility_context);
   }
 
+  if (GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_display_texture_share_group")) {
+    context_attributes.push_back(EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE);
+    context_attributes.push_back(
+        attribs.global_texture_share_group ? EGL_TRUE : EGL_FALSE);
+  } else {
+    DCHECK(!attribs.global_texture_share_group);
+  }
+
+  if (GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_create_context_client_arrays")) {
+    // Disable client arrays if the context supports it
+    context_attributes.push_back(EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE);
+    context_attributes.push_back(EGL_FALSE);
+  }
+
   // Append final EGL_NONE to signal the context attributes are finished
   context_attributes.push_back(EGL_NONE);
   context_attributes.push_back(EGL_NONE);
@@ -157,7 +201,7 @@ bool GLContextEGL::MakeCurrent(GLSurface* surface) {
   }
 
   // Set this as soon as the context is current, since we might call into GL.
-  SetRealGLApi();
+  BindGLApi();
 
   SetCurrent(surface);
   InitializeDynamicBindings();
diff --git a/chromium/ui/gl/gl_context_glx.cc b/chromium/ui/gl/gl_context_glx.cc
index cae4242e044..145162d0b36 100644
--- a/chromium/ui/gl/gl_context_glx.cc
+++ b/chromium/ui/gl/gl_context_glx.cc
@@ -71,69 +71,68 @@ GLXContext CreateContextAttribs(Display* display,
 GLXContext CreateHighestVersionContext(Display* display,
                                        GLXFBConfig config,
                                        GLXContext share) {
-  // It is commonly assumed that glXCreateContextAttrib will create a context
-  // of the highest version possible but it is not specified in the spec and
-  // is not true on the Mesa drivers. On Mesa, Instead we try to create a
-  // context per GL version until we succeed, starting from newer version.
-  // On both Mesa and other drivers we try to create a desktop context and fall
-  // back to ES context.
-  // The code could be simpler if the Mesa code path was used for all drivers,
-  // however the cost of failing a context creation can be high (3 milliseconds
-  // for the NVIDIA driver). The good thing is that failed context creation only
-  // takes 0.1 milliseconds on Mesa.
+  // The only way to get a core profile context of the highest version using
+  // glXCreateContextAttrib is to try creationg contexts in decreasing version
+  // numbers. It might look that asking for a core context of version (0, 0)
+  // works on some driver but it create a _compatibility_ context of the highest
+  // version instead. The cost of failing a context creation is small (< 0.1 ms)
+  // on Mesa but is unfortunately a bit expensive on the Nvidia driver (~3ms).
+
+  // Also try to get any Desktop GL context, but if that fails fallback to
+  // asking for OpenGL ES contexts.
+
+  std::string client_vendor = glXGetClientString(display, GLX_VENDOR);
+  bool is_mesa = client_vendor.find("Mesa") != std::string::npos;
 
   struct ContextCreationInfo {
+    ContextCreationInfo(int profileFlag, GLVersion version)
+        : profileFlag(profileFlag), version(version) {}
     int profileFlag;
     GLVersion version;
   };
 
-  // clang-format off
-  // For regular drivers we try to create a compatibility, core, then ES
-  // context. Without requiring any specific version.
-  const ContextCreationInfo contexts_to_try[] = {
-      { 0, GLVersion(0, 0) },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, GLVersion(0, 0) },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, GLVersion(0, 0) },
-  };
-
-  // On Mesa we try to create a core context, except for versions below 3.2
-  // where it is not applicable. (and fallback to ES as well)
-  const ContextCreationInfo mesa_contexts_to_try[] = {
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 5) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 4) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 3) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 2) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 1) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 0) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(3, 3) } },
-      // Do not try to create OpenGL context versions between 3.0 and
-      // 3.2 because of compatibility problems. crbug.com/659030
-      { 0, { GLVersion(2, 0) } },
-      { 0, { GLVersion(1, 5) } },
-      { 0, { GLVersion(1, 4) } },
-      { 0, { GLVersion(1, 3) } },
-      { 0, { GLVersion(1, 2) } },
-      { 0, { GLVersion(1, 1) } },
-      { 0, { GLVersion(1, 0) } },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, { GLVersion(3, 2) } },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, { GLVersion(3, 1) } },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, { GLVersion(3, 0) } },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, { GLVersion(2, 0) } },
-  };
-  // clang-format on
-
-  std::string client_vendor = glXGetClientString(display, GLX_VENDOR);
-  bool is_mesa = client_vendor.find("Mesa") != std::string::npos;
-
-  const ContextCreationInfo* to_try = contexts_to_try;
-  size_t to_try_length = arraysize(contexts_to_try);
-  if (is_mesa) {
-    to_try = mesa_contexts_to_try;
-    to_try_length = arraysize(mesa_contexts_to_try);
+  std::vector<ContextCreationInfo> contexts_to_try;
+  contexts_to_try.emplace_back(GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                               GLVersion(4, 5));
+  contexts_to_try.emplace_back(GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                               GLVersion(4, 4));
+  contexts_to_try.emplace_back(GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                               GLVersion(4, 3));
+  contexts_to_try.emplace_back(GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                               GLVersion(4, 2));
+  contexts_to_try.emplace_back(GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                               GLVersion(4, 1));
+  contexts_to_try.emplace_back(GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                               GLVersion(4, 0));
+  contexts_to_try.emplace_back(GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                               GLVersion(3, 3));
+
+  // On Mesa, do not try to create OpenGL context versions between 3.0 and
+  // 3.2 because of compatibility problems. See crbug.com/659030
+  if (!is_mesa) {
+    contexts_to_try.emplace_back(0, GLVersion(3, 2));
+    contexts_to_try.emplace_back(0, GLVersion(3, 1));
+    contexts_to_try.emplace_back(0, GLVersion(3, 0));
   }
 
-  for (size_t i = 0; i < to_try_length; ++i) {
-    const ContextCreationInfo& info = to_try[i];
+  contexts_to_try.emplace_back(0, GLVersion(2, 1));
+  contexts_to_try.emplace_back(0, GLVersion(2, 0));
+  contexts_to_try.emplace_back(0, GLVersion(1, 5));
+  contexts_to_try.emplace_back(0, GLVersion(1, 4));
+  contexts_to_try.emplace_back(0, GLVersion(1, 3));
+  contexts_to_try.emplace_back(0, GLVersion(1, 2));
+  contexts_to_try.emplace_back(0, GLVersion(1, 1));
+  contexts_to_try.emplace_back(0, GLVersion(1, 0));
+  contexts_to_try.emplace_back(GLX_CONTEXT_ES2_PROFILE_BIT_EXT,
+                               GLVersion(3, 2));
+  contexts_to_try.emplace_back(GLX_CONTEXT_ES2_PROFILE_BIT_EXT,
+                               GLVersion(3, 1));
+  contexts_to_try.emplace_back(GLX_CONTEXT_ES2_PROFILE_BIT_EXT,
+                               GLVersion(3, 0));
+  contexts_to_try.emplace_back(GLX_CONTEXT_ES2_PROFILE_BIT_EXT,
+                               GLVersion(2, 0));
+
+  for (const auto& info : contexts_to_try) {
     if (!GLSurfaceGLX::IsCreateContextES2ProfileSupported() &&
         info.profileFlag == GLX_CONTEXT_ES2_PROFILE_BIT_EXT) {
       continue;
@@ -243,7 +242,7 @@ bool GLContextGLX::MakeCurrent(GLSurface* surface) {
   }
 
   // Set this as soon as the context is current, since we might call into GL.
-  SetRealGLApi();
+  BindGLApi();
 
   SetCurrent(surface);
   InitializeDynamicBindings();
diff --git a/chromium/ui/gl/gl_context_osmesa.cc b/chromium/ui/gl/gl_context_osmesa.cc
index f63cbce9240..b531eeb239e 100644
--- a/chromium/ui/gl/gl_context_osmesa.cc
+++ b/chromium/ui/gl/gl_context_osmesa.cc
@@ -82,7 +82,7 @@ bool GLContextOSMesa::MakeCurrent(GLSurface* surface) {
   is_released_ = false;
 
   // Set this as soon as the context is current, since we might call into GL.
-  SetRealGLApi();
+  BindGLApi();
 
   // Row 0 is at the top.
   OSMesaPixelStore(OSMESA_Y_UP, 0);
diff --git a/chromium/ui/gl/gl_context_stub.cc b/chromium/ui/gl/gl_context_stub.cc
index a72f08080cc..1c54f9dd42c 100644
--- a/chromium/ui/gl/gl_context_stub.cc
+++ b/chromium/ui/gl/gl_context_stub.cc
@@ -5,12 +5,16 @@
 #include "ui/gl/gl_context_stub.h"
 
 #include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_stub_api.h"
 
 namespace gl {
 
-GLContextStub::GLContextStub() : GLContextReal(nullptr) {}
+GLContextStub::GLContextStub() : GLContextStub(nullptr) {}
 GLContextStub::GLContextStub(GLShareGroup* share_group)
-    : GLContextReal(share_group) {}
+    : GLContextReal(share_group),
+      use_stub_api_(false),
+      version_str_("OpenGL ES 3.0"),
+      extensions_("GL_EXT_framebuffer_object") {}
 
 bool GLContextStub::Initialize(GLSurface* compatible_surface,
                                const GLContextAttribs& attribs) {
@@ -18,7 +22,7 @@ bool GLContextStub::Initialize(GLSurface* compatible_surface,
 }
 
 bool GLContextStub::MakeCurrent(GLSurface* surface) {
-  SetGLToStubGLApi();
+  BindGLApi();
   SetCurrent(surface);
   InitializeDynamicBindings();
   return true;
@@ -39,10 +43,50 @@ void* GLContextStub::GetHandle() {
 void GLContextStub::OnSetSwapInterval(int interval) {
 }
 
+std::string GLContextStub::GetGLVersion() {
+  return version_str_;
+}
+
 std::string GLContextStub::GetGLRenderer() {
   return std::string("CHROMIUM");
 }
 
+bool GLContextStub::WasAllocatedUsingRobustnessExtension() {
+  return HasExtension("GL_ARB_robustness") ||
+         HasExtension("GL_KHR_robustness") || HasExtension("GL_EXT_robustness");
+}
+
+std::string GLContextStub::GetExtensions() {
+  return extensions_;
+}
+
+void GLContextStub::SetUseStubApi(bool stub_api) {
+  use_stub_api_ = stub_api;
+}
+
+void GLContextStub::SetExtensionsString(const char* extensions) {
+  extensions_ = extensions;
+}
+
+void GLContextStub::SetGLVersionString(const char* version_str) {
+  version_str_ = std::string(version_str ? version_str : "");
+}
+
 GLContextStub::~GLContextStub() {}
 
+GLApi* GLContextStub::CreateGLApi(DriverGL* driver) {
+  if (use_stub_api_) {
+    GLStubApi* stub_api = new GLStubApi();
+    if (!version_str_.empty()) {
+      stub_api->set_version(version_str_);
+    }
+    if (!extensions_.empty()) {
+      stub_api->set_extensions(extensions_);
+    }
+    return stub_api;
+  }
+
+  return GLContext::CreateGLApi(driver);
+}
+
 }  // namespace gl
diff --git a/chromium/ui/gl/gl_context_stub.h b/chromium/ui/gl/gl_context_stub.h
index d98927b2c51..7ddc3d1f028 100644
--- a/chromium/ui/gl/gl_context_stub.h
+++ b/chromium/ui/gl/gl_context_stub.h
@@ -27,12 +27,25 @@ class GL_EXPORT GLContextStub : public GLContextReal {
   bool IsCurrent(GLSurface* surface) override;
   void* GetHandle() override;
   void OnSetSwapInterval(int interval) override;
+  std::string GetGLVersion() override;
   std::string GetGLRenderer() override;
+  bool WasAllocatedUsingRobustnessExtension() override;
+  std::string GetExtensions() override;
+
+  void SetUseStubApi(bool stub_api);
+  void SetExtensionsString(const char* extensions);
+  void SetGLVersionString(const char* version_str);
 
  protected:
   ~GLContextStub() override;
 
+  GLApi* CreateGLApi(DriverGL* driver) override;
+
  private:
+  bool use_stub_api_;
+  std::string version_str_;
+  std::string extensions_;
+
   DISALLOW_COPY_AND_ASSIGN(GLContextStub);
 };
 
diff --git a/chromium/ui/gl/gl_context_stub_with_extensions.cc b/chromium/ui/gl/gl_context_stub_with_extensions.cc
deleted file mode 100644
index 3b5677ca1aa..00000000000
--- a/chromium/ui/gl/gl_context_stub_with_extensions.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "ui/gl/gl_context_stub_with_extensions.h"
-
-namespace gl {
-
-void GLContextStubWithExtensions::AddExtensionsString(const char* extensions) {
-  if (extensions == nullptr)
-    return;
-
-  if (extensions_.size() != 0)
-    extensions_ += ' ';
-  extensions_ += extensions;
-}
-
-std::string GLContextStubWithExtensions::GetExtensions() {
-  return extensions_;
-}
-
-void GLContextStubWithExtensions::SetGLVersionString(const char* version_str) {
-  version_str_ = std::string(version_str ? version_str : "");
-}
-
-std::string GLContextStubWithExtensions::GetGLVersion() {
-  return version_str_;
-}
-
-bool GLContextStubWithExtensions::WasAllocatedUsingRobustnessExtension() {
-  return HasExtension("GL_ARB_robustness") ||
-         HasExtension("GL_KHR_robustness") ||
-         HasExtension("GL_EXT_robustness");
-}
-
-}  // namespace gl
diff --git a/chromium/ui/gl/gl_context_stub_with_extensions.h b/chromium/ui/gl/gl_context_stub_with_extensions.h
deleted file mode 100644
index f586c397cb5..00000000000
--- a/chromium/ui/gl/gl_context_stub_with_extensions.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef UI_GL_GL_CONTEXT_STUB_WITH_EXTENSIONS_H_
-#define UI_GL_GL_CONTEXT_STUB_WITH_EXTENSIONS_H_
-
-#include "base/macros.h"
-#include "ui/gl/gl_context_stub.h"
-#include "ui/gl/gl_export.h"
-
-namespace gl {
-
-// Lightweight GLContext stub implementation that returns a constructed
-// extensions string.  We use this to create a context that we can use to
-// initialize GL extensions with, without actually creating a platform context.
-class GL_EXPORT GLContextStubWithExtensions : public GLContextStub {
- public:
-  GLContextStubWithExtensions() {}
-  std::string GetExtensions() override;
-
-  void AddExtensionsString(const char* extensions);
-  void SetGLVersionString(const char* version_str);
-  bool WasAllocatedUsingRobustnessExtension() override;
-
- protected:
-  std::string GetGLVersion() override;
-
-  ~GLContextStubWithExtensions() override {}
-
- private:
-  std::string extensions_;
-  std::string version_str_;
-
-  DISALLOW_COPY_AND_ASSIGN(GLContextStubWithExtensions);
-};
-
-}  // namespace gl
-
-#endif  // UI_GL_GL_CONTEXT_STUB_WITH_EXTENSIONS_H_
diff --git a/chromium/ui/gl/gl_context_wgl.cc b/chromium/ui/gl/gl_context_wgl.cc
index 64b48b87253..726fcb62496 100644
--- a/chromium/ui/gl/gl_context_wgl.cc
+++ b/chromium/ui/gl/gl_context_wgl.cc
@@ -105,7 +105,7 @@ bool GLContextWGL::MakeCurrent(GLSurface* surface) {
   }
 
   // Set this as soon as the context is current, since we might call into GL.
-  SetRealGLApi();
+  BindGLApi();
 
   SetCurrent(surface);
   InitializeDynamicBindings();
diff --git a/chromium/ui/gl/gl_egl_api_implementation.cc b/chromium/ui/gl/gl_egl_api_implementation.cc
index aa3ed1813cf..e0520524b4b 100644
--- a/chromium/ui/gl/gl_egl_api_implementation.cc
+++ b/chromium/ui/gl/gl_egl_api_implementation.cc
@@ -12,20 +12,8 @@
 
 namespace gl {
 
-namespace {
-
-void GL_BINDING_CALL MarshalClearDepthToClearDepthf(GLclampd depth) {
-  glClearDepthf(static_cast<GLclampf>(depth));
-}
-
-void GL_BINDING_CALL MarshalDepthRangeToDepthRangef(GLclampd z_near,
-                                                    GLclampd z_far) {
-  glDepthRangef(static_cast<GLclampf>(z_near), static_cast<GLclampf>(z_far));
-}
-
-}  // namespace
-
-RealEGLApi* g_real_egl;
+RealEGLApi* g_real_egl = nullptr;
+DebugEGLApi* g_debug_egl = nullptr;
 
 void InitializeStaticGLBindingsEGL() {
   g_driver_egl.InitializeStaticBindings();
@@ -34,18 +22,20 @@ void InitializeStaticGLBindingsEGL() {
   }
   g_real_egl->Initialize(&g_driver_egl);
   g_current_egl_context = g_real_egl;
-
-  // These two functions take single precision float rather than double
-  // precision float parameters in GLES.
-  ::gl::g_driver_gl.fn.glClearDepthFn = MarshalClearDepthToClearDepthf;
-  ::gl::g_driver_gl.fn.glDepthRangeFn = MarshalDepthRangeToDepthRangef;
 }
 
 void InitializeDebugGLBindingsEGL() {
-  g_driver_egl.InitializeDebugBindings();
+  if (!g_debug_egl) {
+    g_debug_egl = new DebugEGLApi(g_real_egl);
+  }
+  g_current_egl_context = g_debug_egl;
 }
 
 void ClearBindingsEGL() {
+  if (g_debug_egl) {
+    delete g_debug_egl;
+    g_debug_egl = NULL;
+  }
   if (g_real_egl) {
     delete g_real_egl;
     g_real_egl = NULL;
@@ -110,6 +100,10 @@ const char* RealEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
   return EGLApiBase::eglQueryStringFn(dpy, name);
 }
 
+DebugEGLApi::DebugEGLApi(EGLApi* egl_api) : egl_api_(egl_api) {}
+
+DebugEGLApi::~DebugEGLApi() {}
+
 TraceEGLApi::~TraceEGLApi() {
 }
 
diff --git a/chromium/ui/gl/gl_egl_api_implementation.h b/chromium/ui/gl/gl_egl_api_implementation.h
index 9e6cabd8042..f120aab53fe 100644
--- a/chromium/ui/gl/gl_egl_api_implementation.h
+++ b/chromium/ui/gl/gl_egl_api_implementation.h
@@ -55,6 +55,20 @@ class GL_EXPORT RealEGLApi : public EGLApiBase {
   std::map<EGLDisplay, std::string> filtered_exts_;
 };
 
+// Logs debug information for every EGL call.
+class GL_EXPORT DebugEGLApi : public EGLApi {
+ public:
+  DebugEGLApi(EGLApi* egl_api);
+  ~DebugEGLApi() override;
+
+  // 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_egl.h"
+
+ private:
+  EGLApi* egl_api_;
+};
 
 // Inserts a TRACE for every EGL call.
 class GL_EXPORT TraceEGLApi : public EGLApi {
diff --git a/chromium/ui/gl/gl_fence.cc b/chromium/ui/gl/gl_fence.cc
index 5930a32b0d6..4634cbf42c8 100644
--- a/chromium/ui/gl/gl_fence.cc
+++ b/chromium/ui/gl/gl_fence.cc
@@ -11,7 +11,6 @@
 #include "ui/gl/gl_fence_arb.h"
 #include "ui/gl/gl_fence_egl.h"
 #include "ui/gl/gl_fence_nv.h"
-#include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_version_info.h"
 
@@ -28,15 +27,16 @@ GLFence::~GLFence() {
 }
 
 bool GLFence::IsSupported() {
-  DCHECK(GetGLVersionInfo());
-  return g_driver_gl.ext.b_GL_ARB_sync || GetGLVersionInfo()->is_es3 ||
-         GetGLVersionInfo()->is_desktop_core_profile ||
+  DCHECK(g_current_gl_version && g_current_gl_driver);
+  return g_current_gl_driver->ext.b_GL_ARB_sync ||
+         g_current_gl_version->is_es3 ||
+         g_current_gl_version->is_desktop_core_profile ||
 #if defined(OS_MACOSX)
-         g_driver_gl.ext.b_GL_APPLE_fence ||
+         g_current_gl_driver->ext.b_GL_APPLE_fence ||
 #else
          g_driver_egl.ext.b_EGL_KHR_fence_sync ||
 #endif
-         g_driver_gl.ext.b_GL_NV_fence;
+         g_current_gl_driver->ext.b_GL_NV_fence;
 }
 
 GLFence* GLFence::Create() {
@@ -51,18 +51,19 @@ GLFence* GLFence::Create() {
     fence.reset(new GLFenceEGL);
   } else
 #endif
-      if (g_driver_gl.ext.b_GL_ARB_sync || GetGLVersionInfo()->is_es3 ||
-          GetGLVersionInfo()->is_desktop_core_profile) {
+      if (g_current_gl_driver->ext.b_GL_ARB_sync ||
+          g_current_gl_version->is_es3 ||
+          g_current_gl_version->is_desktop_core_profile) {
     // Prefer ARB_sync which supports server-side wait.
     fence.reset(new GLFenceARB);
 #if defined(OS_MACOSX)
-  } else if (g_driver_gl.ext.b_GL_APPLE_fence) {
+  } else if (g_current_gl_driver->ext.b_GL_APPLE_fence) {
     fence.reset(new GLFenceAPPLE);
 #else
   } else if (g_driver_egl.ext.b_EGL_KHR_fence_sync) {
     fence.reset(new GLFenceEGL);
 #endif
-  } else if (g_driver_gl.ext.b_GL_NV_fence) {
+  } else if (g_current_gl_driver->ext.b_GL_NV_fence) {
     fence.reset(new GLFenceNV);
   }
 
diff --git a/chromium/ui/gl/gl_fence_arb.cc b/chromium/ui/gl/gl_fence_arb.cc
index 8f1711f00ec..7bc089d8bfc 100644
--- a/chromium/ui/gl/gl_fence_arb.cc
+++ b/chromium/ui/gl/gl_fence_arb.cc
@@ -78,8 +78,10 @@ void GLFenceARB::HandleClientWaitFailure() {
   if (GLContext::GetCurrent()->WasAllocatedUsingRobustnessExtension()) {
     // This function pointer is only set if one of the robustness
     // extensions was available.
-    DCHECK(g_driver_gl.fn.glGetGraphicsResetStatusARBFn);
-    DCHECK(g_driver_gl.fn.glGetGraphicsResetStatusARBFn() != GL_NO_ERROR);
+    DCHECK(g_current_gl_driver &&
+           g_current_gl_driver->fn.glGetGraphicsResetStatusARBFn);
+    DCHECK(g_current_gl_driver->fn.glGetGraphicsResetStatusARBFn() !=
+           GL_NO_ERROR);
     LOG(ERROR) << "Failed to wait for GLFence; context was lost. Error code: "
                << GetGLErrors();
   } else {
diff --git a/chromium/ui/gl/gl_gl_api_implementation.cc b/chromium/ui/gl/gl_gl_api_implementation.cc
index 265bd31f2bc..ecd5881e5c6 100644
--- a/chromium/ui/gl/gl_gl_api_implementation.cc
+++ b/chromium/ui/gl/gl_gl_api_implementation.cc
@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ -19,28 +20,25 @@
 
 namespace gl {
 
-// The GL Api being used. This could be g_real_gl or gl_trace_gl
-static GLApi* g_gl = NULL;
-// A GL Api that calls directly into the driver.
-static RealGLApi* g_real_gl = NULL;
-// A GL Api that does nothing but warn about illegal GL calls without a context
-// current.
-static NoContextGLApi* g_no_context_gl = NULL;
-// A GL Api that calls TRACE and then calls another GL api.
-static TraceGLApi* g_trace_gl = NULL;
-// The GL Api being used for stub contexts. If null, g_gl is used instead.
-static GLApi* g_stub_gl = NULL;
-// GL version used when initializing dynamic bindings.
-static GLVersionInfo* g_version_info = NULL;
+// The GL state for when no context is bound
+static CurrentGL* g_no_context_current_gl = nullptr;
+
+// If the null draw bindings are currently enabled.
+// TODO: Consider adding a new GLApi that no-ops these functions
+static bool g_null_draw_bindings_enabled = false;
+
+// If the GL debug bindings are enabled.
+static bool g_debug_bindings_enabled = false;
 
 namespace {
 
-static inline GLenum GetInternalFormat(GLenum internal_format) {
-  if (!g_version_info->is_es) {
+static inline GLenum GetInternalFormat(const GLVersionInfo* version,
+                                       GLenum internal_format) {
+  if (!version->is_es) {
     if (internal_format == GL_BGRA_EXT || internal_format == GL_BGRA8_EXT)
       return GL_RGBA8;
   }
-  if (g_version_info->is_es3 && g_version_info->is_mesa) {
+  if (version->is_es3 && version->is_mesa) {
     // Mesa bug workaround: Mipmapping does not work when using GL_BGRA_EXT
     if (internal_format == GL_BGRA_EXT)
       return GL_RGBA;
@@ -49,14 +47,14 @@ static inline GLenum GetInternalFormat(GLenum internal_format) {
 }
 
 // TODO(epenner): Could the above function be merged into this and removed?
-static inline GLenum GetTexInternalFormat(GLenum internal_format,
+static inline GLenum GetTexInternalFormat(const GLVersionInfo* version,
+                                          GLenum internal_format,
                                           GLenum format,
                                           GLenum type) {
-  DCHECK(g_version_info);
-  GLenum gl_internal_format = GetInternalFormat(internal_format);
+  GLenum gl_internal_format = GetInternalFormat(version, internal_format);
 
   // g_version_info must be initialized when this function is bound.
-  if (g_version_info->is_es3) {
+  if (version->is_es3) {
     if (internal_format == GL_RED_EXT) {
       // GL_EXT_texture_rg case in ES2.
       switch (type) {
@@ -94,8 +92,8 @@ static inline GLenum GetTexInternalFormat(GLenum internal_format,
     }
   }
 
-  if (type == GL_FLOAT && g_version_info->is_angle && g_version_info->is_es &&
-      g_version_info->major_version == 2) {
+  if (type == GL_FLOAT && version->is_angle && version->is_es &&
+      version->major_version == 2) {
     // It's possible that the texture is using a sized internal format, and
     // ANGLE exposing GLES2 API doesn't support those.
     // TODO(oetuaho@nvidia.com): Remove these conversions once ANGLE has the
@@ -113,8 +111,7 @@ static inline GLenum GetTexInternalFormat(GLenum internal_format,
     }
   }
 
-  if (g_version_info->IsAtLeastGL(2, 1) ||
-      g_version_info->IsAtLeastGLES(3, 0)) {
+  if (version->IsAtLeastGL(2, 1) || version->IsAtLeastGLES(3, 0)) {
     switch (internal_format) {
       case GL_SRGB_EXT:
         gl_internal_format = GL_SRGB8;
@@ -127,7 +124,7 @@ static inline GLenum GetTexInternalFormat(GLenum internal_format,
     }
   }
 
-  if (g_version_info->is_es)
+  if (version->is_es)
     return gl_internal_format;
 
   if (type == GL_FLOAT) {
@@ -195,12 +192,10 @@ static inline GLenum GetTexInternalFormat(GLenum internal_format,
   return gl_internal_format;
 }
 
-static inline GLenum GetTexFormat(GLenum format) {
+static inline GLenum GetTexFormat(const GLVersionInfo* version, GLenum format) {
   GLenum gl_format = format;
 
-  DCHECK(g_version_info);
-  if (g_version_info->IsAtLeastGL(2, 1) ||
-      g_version_info->IsAtLeastGLES(3, 0)) {
+  if (version->IsAtLeastGL(2, 1) || version->IsAtLeastGLES(3, 0)) {
     switch (format) {
       case GL_SRGB_EXT:
         gl_format = GL_RGB;
@@ -216,271 +211,64 @@ static inline GLenum GetTexFormat(GLenum format) {
   return gl_format;
 }
 
-static inline GLenum GetTexType(GLenum type) {
-  if (!g_version_info->is_es) {
+static inline GLenum GetTexType(const GLVersionInfo* version, GLenum type) {
+  if (!version->is_es) {
     if (type == GL_HALF_FLOAT_OES)
       return GL_HALF_FLOAT_ARB;
   }
   return type;
 }
 
-static void GL_BINDING_CALL CustomTexImage2D(
-    GLenum target, GLint level, GLint internalformat,
-    GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
-    const void* pixels) {
-  GLenum gl_internal_format = GetTexInternalFormat(
-      internalformat, format, type);
-  GLenum gl_format = GetTexFormat(format);
-  GLenum gl_type = GetTexType(type);
-  g_driver_gl.orig_fn.glTexImage2DFn(
-      target, level, gl_internal_format, width, height, border, gl_format,
-      gl_type, pixels);
-}
-
-static void GL_BINDING_CALL CustomTexSubImage2D(
-      GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
-      GLsizei height, GLenum format, GLenum type, const void* pixels) {
-  GLenum gl_format = GetTexFormat(format);
-  GLenum gl_type = GetTexType(type);
-  g_driver_gl.orig_fn.glTexSubImage2DFn(
-      target, level, xoffset, yoffset, width, height, gl_format, gl_type,
-      pixels);
-}
-
-static void GL_BINDING_CALL CustomTexStorage2DEXT(
-    GLenum target, GLsizei levels, GLenum internalformat, GLsizei width,
-    GLsizei height) {
-  GLenum gl_internal_format = GetInternalFormat(internalformat);
-  g_driver_gl.orig_fn.glTexStorage2DEXTFn(
-      target, levels, gl_internal_format, width, height);
-}
-
-static void GL_BINDING_CALL CustomRenderbufferStorageEXT(
-    GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
-  GLenum gl_internal_format = GetInternalFormat(internalformat);
-  g_driver_gl.orig_fn.glRenderbufferStorageEXTFn(
-      target, gl_internal_format, width, height);
-}
-
-// The ANGLE and IMG variants of glRenderbufferStorageMultisample currently do
-// not support BGRA render buffers so only the EXT one is customized. If
-// GL_CHROMIUM_renderbuffer_format_BGRA8888 support is added to ANGLE then the
-// ANGLE version should also be customized.
-static void GL_BINDING_CALL CustomRenderbufferStorageMultisampleEXT(
-    GLenum target, GLsizei samples, GLenum internalformat, GLsizei width,
-    GLsizei height) {
-  GLenum gl_internal_format = GetInternalFormat(internalformat);
-  g_driver_gl.orig_fn.glRenderbufferStorageMultisampleEXTFn(
-      target, samples, gl_internal_format, width, height);
-}
-
-static void GL_BINDING_CALL
-CustomRenderbufferStorageMultisample(GLenum target,
-                                     GLsizei samples,
-                                     GLenum internalformat,
-                                     GLsizei width,
-                                     GLsizei height) {
-  GLenum gl_internal_format = GetInternalFormat(internalformat);
-  g_driver_gl.orig_fn.glRenderbufferStorageMultisampleFn(
-      target, samples, gl_internal_format, width, height);
-}
-
 }  // anonymous namespace
 
-void DriverGL::InitializeCustomDynamicBindings(GLContext* context) {
-  InitializeDynamicBindings(context);
-
-  DCHECK(orig_fn.glTexImage2DFn == NULL);
-  orig_fn.glTexImage2DFn = fn.glTexImage2DFn;
-  fn.glTexImage2DFn =
-      reinterpret_cast<glTexImage2DProc>(CustomTexImage2D);
-
-  DCHECK(orig_fn.glTexSubImage2DFn == NULL);
-  orig_fn.glTexSubImage2DFn = fn.glTexSubImage2DFn;
-  fn.glTexSubImage2DFn =
-      reinterpret_cast<glTexSubImage2DProc>(CustomTexSubImage2D);
-
-  DCHECK(orig_fn.glTexStorage2DEXTFn == NULL);
-  orig_fn.glTexStorage2DEXTFn = fn.glTexStorage2DEXTFn;
-  fn.glTexStorage2DEXTFn =
-      reinterpret_cast<glTexStorage2DEXTProc>(CustomTexStorage2DEXT);
-
-  DCHECK(orig_fn.glRenderbufferStorageEXTFn == NULL);
-  orig_fn.glRenderbufferStorageEXTFn = fn.glRenderbufferStorageEXTFn;
-  fn.glRenderbufferStorageEXTFn =
-      reinterpret_cast<glRenderbufferStorageEXTProc>(
-      CustomRenderbufferStorageEXT);
-
-  DCHECK(orig_fn.glRenderbufferStorageMultisampleEXTFn == NULL);
-  orig_fn.glRenderbufferStorageMultisampleEXTFn =
-      fn.glRenderbufferStorageMultisampleEXTFn;
-  fn.glRenderbufferStorageMultisampleEXTFn =
-      reinterpret_cast<glRenderbufferStorageMultisampleEXTProc>(
-      CustomRenderbufferStorageMultisampleEXT);
-
-  DCHECK(orig_fn.glRenderbufferStorageMultisampleFn == NULL);
-  orig_fn.glRenderbufferStorageMultisampleFn =
-      fn.glRenderbufferStorageMultisampleFn;
-  fn.glRenderbufferStorageMultisampleFn =
-      reinterpret_cast<glRenderbufferStorageMultisampleProc>(
-          CustomRenderbufferStorageMultisample);
-}
-
-static void GL_BINDING_CALL NullDrawClearFn(GLbitfield mask) {
-  if (!g_driver_gl.null_draw_bindings_enabled)
-    g_driver_gl.orig_fn.glClearFn(mask);
-}
-
-static void GL_BINDING_CALL
-NullDrawDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
-  if (!g_driver_gl.null_draw_bindings_enabled)
-    g_driver_gl.orig_fn.glDrawArraysFn(mode, first, count);
-}
-
-static void GL_BINDING_CALL NullDrawDrawElementsFn(GLenum mode,
-                                                   GLsizei count,
-                                                   GLenum type,
-                                                   const void* indices) {
-  if (!g_driver_gl.null_draw_bindings_enabled)
-    g_driver_gl.orig_fn.glDrawElementsFn(mode, count, type, indices);
-}
-
-void DriverGL::InitializeNullDrawBindings() {
-  DCHECK(orig_fn.glClearFn == NULL);
-  orig_fn.glClearFn = fn.glClearFn;
-  fn.glClearFn = NullDrawClearFn;
-
-  DCHECK(orig_fn.glDrawArraysFn == NULL);
-  orig_fn.glDrawArraysFn = fn.glDrawArraysFn;
-  fn.glDrawArraysFn = NullDrawDrawArraysFn;
-
-  DCHECK(orig_fn.glDrawElementsFn == NULL);
-  orig_fn.glDrawElementsFn = fn.glDrawElementsFn;
-  fn.glDrawElementsFn = NullDrawDrawElementsFn;
-
-  null_draw_bindings_enabled = true;
-}
-
-bool DriverGL::HasInitializedNullDrawBindings() {
-  return orig_fn.glClearFn != NULL && orig_fn.glDrawArraysFn != NULL &&
-         orig_fn.glDrawElementsFn != NULL;
-}
-
-bool DriverGL::SetNullDrawBindingsEnabled(bool enabled) {
-  DCHECK(orig_fn.glClearFn != NULL);
-  DCHECK(orig_fn.glDrawArraysFn != NULL);
-  DCHECK(orig_fn.glDrawElementsFn != NULL);
-
-  bool before = null_draw_bindings_enabled;
-  null_draw_bindings_enabled = enabled;
-  return before;
-}
-
 void InitializeStaticGLBindingsGL() {
-  g_current_gl_context_tls = new base::ThreadLocalPointer<GLApi>;
-  g_driver_gl.InitializeStaticBindings();
-  if (!g_real_gl) {
-    g_real_gl = new RealGLApi();
-    g_trace_gl = new TraceGLApi(g_real_gl);
-    g_no_context_gl = new NoContextGLApi();
-  }
-  g_real_gl->Initialize(&g_driver_gl);
-  g_gl = g_real_gl;
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableGPUServiceTracing)) {
-    g_gl = g_trace_gl;
-  }
-  SetGLToRealGLApi();
-}
-
-GLApi* GetCurrentGLApi() {
-  return g_current_gl_context_tls ? g_current_gl_context_tls->Get() : nullptr;
-}
-
-void SetGLApi(GLApi* api) {
-  g_current_gl_context_tls->Set(api);
-}
-
-void SetGLToRealGLApi() {
-  SetGLApi(g_gl);
-}
-
-void SetGLToStubGLApi() {
-  SetGLApi(g_stub_gl ? g_stub_gl : g_gl);
-}
-
-void SetGLApiToNoContext() {
-  SetGLApi(g_no_context_gl);
-}
-
-void SetStubGLApi(GLApi* api) {
-  g_stub_gl = api;
+  g_current_gl_context_tls = new base::ThreadLocalPointer<CurrentGL>;
+  g_no_context_current_gl = new CurrentGL;
+  g_no_context_current_gl->Api = new NoContextGLApi;
 }
 
-const GLVersionInfo* GetGLVersionInfo() {
-  return g_version_info;
-}
+void ClearBindingsGL() {
+  if (g_no_context_current_gl) {
+    delete g_no_context_current_gl->Api;
+    delete g_no_context_current_gl->Driver;
+    delete g_no_context_current_gl->Version;
+    delete g_no_context_current_gl;
+    g_no_context_current_gl = nullptr;
+  }
 
-void InitializeDynamicGLBindingsGL(GLContext* context) {
-  if (g_version_info)
-    return;
-  g_real_gl->InitializeFilteredExtensions();
-  g_driver_gl.InitializeCustomDynamicBindings(context);
-  DCHECK(context && context->IsCurrent(NULL) && !g_version_info);
-  g_version_info = new GLVersionInfo(
-      context->GetGLVersion().c_str(),
-      context->GetGLRenderer().c_str(),
-      context->GetExtensions().c_str());
+  if (g_current_gl_context_tls) {
+    delete g_current_gl_context_tls;
+    g_current_gl_context_tls = nullptr;
+  }
 }
 
 void InitializeDebugGLBindingsGL() {
-  g_driver_gl.InitializeDebugBindings();
+  g_debug_bindings_enabled = true;
 }
 
-void InitializeNullDrawGLBindingsGL() {
-  g_driver_gl.InitializeNullDrawBindings();
+bool GetDebugGLBindingsInitializedGL() {
+  return g_debug_bindings_enabled;
 }
 
-bool HasInitializedNullDrawGLBindingsGL() {
-  return g_driver_gl.HasInitializedNullDrawBindings();
+bool SetNullDrawGLBindingsEnabled(bool enabled) {
+  bool old_value = g_null_draw_bindings_enabled;
+  g_null_draw_bindings_enabled = enabled;
+  return old_value;
 }
 
-bool SetNullDrawGLBindingsEnabledGL(bool enabled) {
-  return g_driver_gl.SetNullDrawBindingsEnabled(enabled);
+bool GetNullDrawBindingsEnabled() {
+  return g_null_draw_bindings_enabled;
 }
 
-void ClearBindingsGL() {
-  if (g_real_gl) {
-    delete g_real_gl;
-    g_real_gl = NULL;
-  }
-  if (g_trace_gl) {
-    delete g_trace_gl;
-    g_trace_gl = NULL;
-  }
-  if (g_no_context_gl) {
-    delete g_no_context_gl;
-    g_no_context_gl = NULL;
-  }
-  g_gl = NULL;
-  g_stub_gl = NULL;
-  g_driver_gl.ClearBindings();
-  if (g_current_gl_context_tls) {
-    delete g_current_gl_context_tls;
-    g_current_gl_context_tls = NULL;
-  }
-  if (g_version_info) {
-    delete g_version_info;
-    g_version_info = NULL;
-  }
+void SetCurrentGL(CurrentGL* current) {
+  CurrentGL* new_current = current ? current : g_no_context_current_gl;
+  g_current_gl_context_tls->Set(new_current);
 }
 
 GLApi::GLApi() {
 }
 
 GLApi::~GLApi() {
-  if (GetCurrentGLApi() == this)
-    SetGLApi(NULL);
 }
 
 GLApiBase::GLApiBase()
@@ -555,10 +343,130 @@ const GLubyte* RealGLApi::glGetStringiFn(GLenum name, GLuint index) {
   return GLApiBase::glGetStringiFn(name, index);
 }
 
+void RealGLApi::glTexImage2DFn(GLenum target,
+                               GLint level,
+                               GLint internalformat,
+                               GLsizei width,
+                               GLsizei height,
+                               GLint border,
+                               GLenum format,
+                               GLenum type,
+                               const void* pixels) {
+  GLenum gl_internal_format =
+      GetTexInternalFormat(version_.get(), internalformat, format, type);
+  GLenum gl_format = GetTexFormat(version_.get(), format);
+  GLenum gl_type = GetTexType(version_.get(), type);
+  GLApiBase::glTexImage2DFn(target, level, gl_internal_format, width, height,
+                            border, gl_format, gl_type, pixels);
+}
+
+void RealGLApi::glTexSubImage2DFn(GLenum target,
+                                  GLint level,
+                                  GLint xoffset,
+                                  GLint yoffset,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLenum format,
+                                  GLenum type,
+                                  const void* pixels) {
+  GLenum gl_format = GetTexFormat(version_.get(), format);
+  GLenum gl_type = GetTexType(version_.get(), type);
+  GLApiBase::glTexSubImage2DFn(target, level, xoffset, yoffset, width, height,
+                               gl_format, gl_type, pixels);
+}
+
+void RealGLApi::glTexStorage2DEXTFn(GLenum target,
+                                    GLsizei levels,
+                                    GLenum internalformat,
+                                    GLsizei width,
+                                    GLsizei height) {
+  GLenum gl_internal_format = GetInternalFormat(version_.get(), internalformat);
+  GLApiBase::glTexStorage2DEXTFn(target, levels, gl_internal_format, width,
+                                 height);
+}
+
+void RealGLApi::glRenderbufferStorageEXTFn(GLenum target,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height) {
+  GLenum gl_internal_format = GetInternalFormat(version_.get(), internalformat);
+  GLApiBase::glRenderbufferStorageEXTFn(target, gl_internal_format, width,
+                                        height);
+}
+
+// The ANGLE and IMG variants of glRenderbufferStorageMultisample currently do
+// not support BGRA render buffers so only the EXT one is customized. If
+// GL_CHROMIUM_renderbuffer_format_BGRA8888 support is added to ANGLE then the
+// ANGLE version should also be customized.
+void RealGLApi::glRenderbufferStorageMultisampleEXTFn(GLenum target,
+                                                      GLsizei samples,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height) {
+  GLenum gl_internal_format = GetInternalFormat(version_.get(), internalformat);
+  GLApiBase::glRenderbufferStorageMultisampleEXTFn(
+      target, samples, gl_internal_format, width, height);
+}
+
+void RealGLApi::glRenderbufferStorageMultisampleFn(GLenum target,
+                                                   GLsizei samples,
+                                                   GLenum internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height) {
+  GLenum gl_internal_format = GetInternalFormat(version_.get(), internalformat);
+  GLApiBase::glRenderbufferStorageMultisampleFn(
+      target, samples, gl_internal_format, width, height);
+}
+
+void RealGLApi::glClearFn(GLbitfield mask) {
+  if (!g_null_draw_bindings_enabled)
+    GLApiBase::glClearFn(mask);
+}
+
+void RealGLApi::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
+  if (!g_null_draw_bindings_enabled)
+    GLApiBase::glDrawArraysFn(mode, first, count);
+}
+
+void RealGLApi::glDrawElementsFn(GLenum mode,
+                                 GLsizei count,
+                                 GLenum type,
+                                 const void* indices) {
+  if (!g_null_draw_bindings_enabled)
+    GLApiBase::glDrawElementsFn(mode, count, type, indices);
+}
+
+void RealGLApi::glClearDepthFn(GLclampd depth) {
+  // OpenGL ES only has glClearDepthf, forward the parameters from glClearDepth.
+  // Many mock tests expect only glClearDepth is called so don't make the
+  // interception when testing with mocks.
+  if (version_->is_es && GetGLImplementation() != kGLImplementationMockGL) {
+    DCHECK(driver_->fn.glClearDepthfFn);
+    GLApiBase::glClearDepthfFn(static_cast<GLclampf>(depth));
+  } else {
+    DCHECK(driver_->fn.glClearDepthFn);
+    GLApiBase::glClearDepthFn(depth);
+  }
+}
+
+void RealGLApi::glDepthRangeFn(GLclampd z_near, GLclampd z_far) {
+  // OpenGL ES only has glDepthRangef, forward the parameters from glDepthRange.
+  // Many mock tests expect only glDepthRange is called so don't make the
+  // interception when testing with mocks.
+  if (version_->is_es && GetGLImplementation() != kGLImplementationMockGL) {
+    DCHECK(driver_->fn.glDepthRangefFn);
+    GLApiBase::glDepthRangefFn(static_cast<GLclampf>(z_near),
+                               static_cast<GLclampf>(z_far));
+  } else {
+    DCHECK(driver_->fn.glDepthRangeFn);
+    GLApiBase::glDepthRangeFn(z_near, z_far);
+  }
+}
+
 void RealGLApi::InitializeFilteredExtensions() {
   if (disabled_exts_.size()) {
     filtered_exts_.clear();
-    if (WillUseGLGetStringForExtensions()) {
+    if (WillUseGLGetStringForExtensions(this)) {
       filtered_exts_str_ =
           FilterGLExtensionList(reinterpret_cast<const char*>(
                                     GLApiBase::glGetStringFn(GL_EXTENSIONS)),
@@ -583,9 +491,17 @@ void RealGLApi::InitializeFilteredExtensions() {
   }
 }
 
+void RealGLApi::set_version(std::unique_ptr<GLVersionInfo> version) {
+  version_ = std::move(version);
+}
+
 TraceGLApi::~TraceGLApi() {
 }
 
+DebugGLApi::DebugGLApi(GLApi* gl_api) : gl_api_(gl_api) {}
+
+DebugGLApi::~DebugGLApi() {}
+
 NoContextGLApi::NoContextGLApi() {
 }
 
diff --git a/chromium/ui/gl/gl_gl_api_implementation.h b/chromium/ui/gl/gl_gl_api_implementation.h
index 806f4535a4c..ba66b85ddf6 100644
--- a/chromium/ui/gl/gl_gl_api_implementation.h
+++ b/chromium/ui/gl/gl_gl_api_implementation.h
@@ -5,6 +5,7 @@
 #ifndef UI_GL_GL_GL_API_IMPLEMENTATION_H_
 #define UI_GL_GL_GL_API_IMPLEMENTATION_H_
 
+#include <memory>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ -17,24 +18,18 @@ class CommandLine;
 
 namespace gl {
 
-class GLContext;
 struct GLVersionInfo;
 
 GL_EXPORT void InitializeStaticGLBindingsGL();
-void InitializeDynamicGLBindingsGL(GLContext* context);
-GL_EXPORT void InitializeDebugGLBindingsGL();
-void InitializeNullDrawGLBindingsGL();
-// TODO(danakj): Remove this when all test suites are using null-draw.
-bool HasInitializedNullDrawGLBindingsGL();
-bool SetNullDrawGLBindingsEnabledGL(bool enabled);
 GL_EXPORT void ClearBindingsGL();
-void SetGLToRealGLApi();
-void SetGLToStubGLApi();
-void SetGLApi(GLApi* api);
-void SetGLApiToNoContext();
-GLApi* GetCurrentGLApi();
-GL_EXPORT void SetStubGLApi(GLApi* api);
-const GLVersionInfo* GetGLVersionInfo();
+
+GL_EXPORT void InitializeDebugGLBindingsGL();
+bool GetDebugGLBindingsInitializedGL();
+
+bool SetNullDrawGLBindingsEnabled(bool enabled);
+bool GetNullDrawBindingsEnabled();
+
+void SetCurrentGL(CurrentGL* current);
 
 class GL_EXPORT GLApiBase : public GLApi {
  public:
@@ -64,7 +59,61 @@ class GL_EXPORT RealGLApi : public GLApiBase {
   const GLubyte* glGetStringFn(GLenum name) override;
   const GLubyte* glGetStringiFn(GLenum name, GLuint index) override;
 
+  void glTexImage2DFn(GLenum target,
+                      GLint level,
+                      GLint internalformat,
+                      GLsizei width,
+                      GLsizei height,
+                      GLint border,
+                      GLenum format,
+                      GLenum type,
+                      const void* pixels) override;
+
+  void glTexSubImage2DFn(GLenum target,
+                         GLint level,
+                         GLint xoffset,
+                         GLint yoffset,
+                         GLsizei width,
+                         GLsizei height,
+                         GLenum format,
+                         GLenum type,
+                         const void* pixels) override;
+
+  void glTexStorage2DEXTFn(GLenum target,
+                           GLsizei levels,
+                           GLenum internalformat,
+                           GLsizei width,
+                           GLsizei height) override;
+
+  void glRenderbufferStorageEXTFn(GLenum target,
+                                  GLenum internalformat,
+                                  GLsizei width,
+                                  GLsizei height) override;
+
+  void glRenderbufferStorageMultisampleEXTFn(GLenum target,
+                                             GLsizei samples,
+                                             GLenum internalformat,
+                                             GLsizei width,
+                                             GLsizei height) override;
+
+  void glRenderbufferStorageMultisampleFn(GLenum target,
+                                          GLsizei samples,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height) override;
+
+  void glClearFn(GLbitfield mask) override;
+  void glDrawArraysFn(GLenum mode, GLint first, GLsizei count) override;
+  void glDrawElementsFn(GLenum mode,
+                        GLsizei count,
+                        GLenum type,
+                        const void* indices) override;
+
+  void glClearDepthFn(GLclampd depth) override;
+  void glDepthRangeFn(GLclampd z_near, GLclampd z_far) override;
+
   void InitializeFilteredExtensions();
+  void set_version(std::unique_ptr<GLVersionInfo> version);
 
  private:
   // Filtered GL_EXTENSIONS we return to glGetString(i) calls.
@@ -72,6 +121,8 @@ class GL_EXPORT RealGLApi : public GLApiBase {
   std::vector<std::string> filtered_exts_;
   std::string filtered_exts_str_;
 
+  std::unique_ptr<GLVersionInfo> version_;
+
 #if DCHECK_IS_ON()
   bool filtered_exts_initialized_;
 #endif
@@ -92,6 +143,21 @@ class TraceGLApi : public GLApi {
   GLApi* gl_api_;
 };
 
+// Logs debug information for every GL call.
+class DebugGLApi : public GLApi {
+ public:
+  DebugGLApi(GLApi* gl_api);
+  ~DebugGLApi() override;
+
+  // 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"
+
+ private:
+  GLApi* gl_api_;
+};
+
 // Catches incorrect usage when GL calls are made without a current context.
 class NoContextGLApi : public GLApi {
  public:
diff --git a/chromium/ui/gl/gl_glx_api_implementation.cc b/chromium/ui/gl/gl_glx_api_implementation.cc
index 01734bb7087..413a385f2e6 100644
--- a/chromium/ui/gl/gl_glx_api_implementation.cc
+++ b/chromium/ui/gl/gl_glx_api_implementation.cc
@@ -12,6 +12,7 @@
 namespace gl {
 
 RealGLXApi* g_real_glx;
+DebugGLXApi* g_debug_glx;
 
 void InitializeStaticGLBindingsGLX() {
   g_driver_glx.InitializeStaticBindings();
@@ -24,10 +25,17 @@ void InitializeStaticGLBindingsGLX() {
 }
 
 void InitializeDebugGLBindingsGLX() {
-  g_driver_glx.InitializeDebugBindings();
+  if (!g_debug_glx) {
+    g_debug_glx = new DebugGLXApi(g_real_glx);
+  }
+  g_current_glx_context = g_debug_glx;
 }
 
 void ClearBindingsGLX() {
+  if (g_debug_glx) {
+    delete g_debug_glx;
+    g_debug_glx = NULL;
+  }
   if (g_real_glx) {
     delete g_real_glx;
     g_real_glx = NULL;
@@ -96,6 +104,9 @@ const char* RealGLXApi::glXQueryExtensionsStringFn(Display* dpy,
   return filtered_exts_.c_str();
 }
 
+DebugGLXApi::DebugGLXApi(GLXApi* glx_api) : glx_api_(glx_api) {}
+DebugGLXApi::~DebugGLXApi() {}
+
 TraceGLXApi::~TraceGLXApi() {
 }
 
diff --git a/chromium/ui/gl/gl_glx_api_implementation.h b/chromium/ui/gl/gl_glx_api_implementation.h
index 9796d9cfae4..2c1815757ca 100644
--- a/chromium/ui/gl/gl_glx_api_implementation.h
+++ b/chromium/ui/gl/gl_glx_api_implementation.h
@@ -53,6 +53,21 @@ class GL_EXPORT RealGLXApi : public GLXApiBase {
   std::string filtered_exts_;
 };
 
+// Logs debug information for every GLX call.
+class GL_EXPORT DebugGLXApi : public GLXApi {
+ public:
+  DebugGLXApi(GLXApi* glx_api);
+  ~DebugGLXApi() override;
+
+  // 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_glx.h"
+
+ private:
+  GLXApi* glx_api_;
+};
+
 // Inserts a TRACE for every GLX call.
 class GL_EXPORT TraceGLXApi : public GLXApi {
  public:
diff --git a/chromium/ui/gl/gl_image_io_surface.mm b/chromium/ui/gl/gl_image_io_surface.mm
index e56e4f21d77..7b24aeaa67e 100644
--- a/chromium/ui/gl/gl_image_io_surface.mm
+++ b/chromium/ui/gl/gl_image_io_surface.mm
@@ -16,7 +16,6 @@
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
-#include "ui/gl/scoped_api.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/yuv_to_rgb_converter.h"
 
@@ -280,8 +279,6 @@ bool GLImageIOSurface::CopyTexImage(unsigned target) {
   YUVToRGBConverter* yuv_to_rgb_converter = gl_context->GetYUVToRGBConverter();
   DCHECK(yuv_to_rgb_converter);
 
-  ScopedSetGLToRealGLApi scoped_set_gl_api;
-
   // Note that state restoration is done explicitly instead of scoped binders to
   // avoid https://crbug.com/601729.
   GLint rgb_texture = 0;
diff --git a/chromium/ui/gl/gl_image_memory.cc b/chromium/ui/gl/gl_image_memory.cc
index 8fda6369472..43c82014d90 100644
--- a/chromium/ui/gl/gl_image_memory.cc
+++ b/chromium/ui/gl/gl_image_memory.cc
@@ -314,7 +314,7 @@ std::unique_ptr<uint8_t[]> GLES2Data(const gfx::Size& size,
       size_t gles2_data_stride =
           RowSizeForBufferFormat(size.width(), format, 0);
       if (stride == gles2_data_stride ||
-          g_driver_gl.ext.b_GL_EXT_unpack_subimage)
+          g_current_gl_driver->ext.b_GL_EXT_unpack_subimage)
         return nullptr;  // No data conversion needed
 
       std::unique_ptr<uint8_t[]> gles2_data(
diff --git a/chromium/ui/gl/gl_implementation.cc b/chromium/ui/gl/gl_implementation.cc
index 0b88b820f71..9235cb935e5 100644
--- a/chromium/ui/gl/gl_implementation.cc
+++ b/chromium/ui/gl/gl_implementation.cc
@@ -13,6 +13,7 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
@@ -28,14 +29,14 @@ const struct {
   const char* name;
   GLImplementation implementation;
 } kGLImplementationNamePairs[] = {
-  { kGLImplementationDesktopName, kGLImplementationDesktopGL },
-  { kGLImplementationOSMesaName, kGLImplementationOSMesaGL },
+    {kGLImplementationDesktopName, kGLImplementationDesktopGL},
+    {kGLImplementationOSMesaName, kGLImplementationOSMesaGL},
+    {kGLImplementationSwiftShaderName, kGLImplementationSwiftShaderGL},
 #if defined(OS_MACOSX)
-  { kGLImplementationAppleName, kGLImplementationAppleGL },
+    {kGLImplementationAppleName, kGLImplementationAppleGL},
 #endif
-  { kGLImplementationEGLName, kGLImplementationEGLGLES2 },
-  { kGLImplementationMockName, kGLImplementationMockGL }
-};
+    {kGLImplementationEGLName, kGLImplementationEGLGLES2},
+    {kGLImplementationMockName, kGLImplementationMockGL}};
 
 typedef std::vector<base::NativeLibrary> LibraryArray;
 
@@ -55,7 +56,7 @@ void CleanupNativeLibraries(void* unused) {
 
 }  // namespace
 
-base::ThreadLocalPointer<GLApi>* g_current_gl_context_tls = NULL;
+base::ThreadLocalPointer<CurrentGL>* g_current_gl_context_tls = NULL;
 OSMESAApi* g_current_osmesa_context;
 
 #if defined(USE_EGL)
@@ -79,6 +80,10 @@ GLImplementation GetNamedGLImplementation(const std::string& name) {
   return kGLImplementationNone;
 }
 
+GLImplementation GetSoftwareGLImplementation() {
+  return kGLImplementationOSMesaGL;
+}
+
 const char* GetGLImplementationName(GLImplementation implementation) {
   for (size_t i = 0; i < arraysize(kGLImplementationNamePairs); ++i) {
     if (implementation == kGLImplementationNamePairs[i].implementation)
@@ -144,13 +149,11 @@ GLFunctionPointerType GetGLProcAddress(const char* name) {
 }
 
 void InitializeNullDrawGLBindings() {
-  // This is platform independent, so it does not need to live in a platform
-  // specific implementation file.
-  InitializeNullDrawGLBindingsGL();
+  SetNullDrawGLBindingsEnabled(true);
 }
 
 bool HasInitializedNullDrawGLBindings() {
-  return HasInitializedNullDrawGLBindingsGL();
+  return GetNullDrawBindingsEnabled();
 }
 
 std::string FilterGLExtensionList(
@@ -174,36 +177,47 @@ std::string FilterGLExtensionList(
 }
 
 DisableNullDrawGLBindings::DisableNullDrawGLBindings() {
-  initial_enabled_ = SetNullDrawGLBindingsEnabledGL(false);
+  initial_enabled_ = SetNullDrawGLBindingsEnabled(false);
 }
 
 DisableNullDrawGLBindings::~DisableNullDrawGLBindings() {
-  SetNullDrawGLBindingsEnabledGL(initial_enabled_);
+  SetNullDrawGLBindingsEnabled(initial_enabled_);
 }
 
 GLWindowSystemBindingInfo::GLWindowSystemBindingInfo()
     : direct_rendering(true) {}
 
 std::string GetGLExtensionsFromCurrentContext() {
-  if (WillUseGLGetStringForExtensions()) {
-    return reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
+  return GetGLExtensionsFromCurrentContext(g_current_gl_context);
+}
+
+std::string GetGLExtensionsFromCurrentContext(GLApi* api) {
+  if (WillUseGLGetStringForExtensions(api)) {
+    const char* extensions =
+        reinterpret_cast<const char*>(api->glGetStringFn(GL_EXTENSIONS));
+    return extensions ? std::string(extensions) : std::string();
   }
 
-  std::vector<std::string> exts;
   GLint num_extensions = 0;
-  glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
+  api->glGetIntegervFn(GL_NUM_EXTENSIONS, &num_extensions);
+
+  std::vector<std::string> exts(num_extensions);
   for (GLint i = 0; i < num_extensions; ++i) {
-    const char* extension = reinterpret_cast<const char*>(
-        glGetStringi(GL_EXTENSIONS, i));
+    const char* extension =
+        reinterpret_cast<const char*>(api->glGetStringiFn(GL_EXTENSIONS, i));
     DCHECK(extension != NULL);
-    exts.push_back(extension);
+    exts[i] = extension;
   }
   return base::JoinString(exts, " ");
 }
 
 bool WillUseGLGetStringForExtensions() {
+  return WillUseGLGetStringForExtensions(g_current_gl_context);
+}
+
+bool WillUseGLGetStringForExtensions(GLApi* api) {
   const char* version_str =
-      reinterpret_cast<const char*>(glGetString(GL_VERSION));
+      reinterpret_cast<const char*>(api->glGetStringFn(GL_VERSION));
   unsigned major_version, minor_version;
   bool is_es, is_es2, is_es3;
   GLVersionInfo::ParseVersionString(version_str, &major_version, &minor_version,
@@ -211,6 +225,14 @@ bool WillUseGLGetStringForExtensions() {
   return is_es || major_version < 3;
 }
 
+std::unique_ptr<GLVersionInfo> GetVersionInfoFromContext(GLApi* api) {
+  std::string extensions = GetGLExtensionsFromCurrentContext(api);
+  return base::MakeUnique<GLVersionInfo>(
+      reinterpret_cast<const char*>(api->glGetStringFn(GL_VERSION)),
+      reinterpret_cast<const char*>(api->glGetStringFn(GL_RENDERER)),
+      extensions.c_str());
+}
+
 base::NativeLibrary LoadLibraryAndPrintError(
     const base::FilePath::CharType* filename) {
   return LoadLibraryAndPrintError(base::FilePath(filename));
diff --git a/chromium/ui/gl/gl_implementation.h b/chromium/ui/gl/gl_implementation.h
index dc425076a09..28cbde27188 100644
--- a/chromium/ui/gl/gl_implementation.h
+++ b/chromium/ui/gl/gl_implementation.h
@@ -5,6 +5,7 @@
 #ifndef UI_GL_GL_IMPLEMENTATION_H_
 #define UI_GL_GL_IMPLEMENTATION_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -16,15 +17,20 @@
 
 namespace gl {
 
+class GLApi;
+struct GLVersionInfo;
+
 // The GL implementation currently in use.
 enum GLImplementation {
   kGLImplementationNone,
   kGLImplementationDesktopGL,
   kGLImplementationDesktopGLCoreProfile,
   kGLImplementationOSMesaGL,
+  kGLImplementationSwiftShaderGL,
   kGLImplementationAppleGL,
   kGLImplementationEGLGLES2,
-  kGLImplementationMockGL
+  kGLImplementationMockGL,
+  kGLImplementationStubGL,
 };
 
 struct GL_EXPORT GLWindowSystemBindingInfo {
@@ -73,6 +79,9 @@ GL_EXPORT void SetGLImplementation(GLImplementation implementation);
 // Get the current GL implementation.
 GL_EXPORT GLImplementation GetGLImplementation();
 
+// Get the software GL implementation for the current platform.
+GL_EXPORT GLImplementation GetSoftwareGLImplementation();
+
 // Does the underlying GL support all features from Desktop GL 2.0 that were
 // removed from the ES 2.0 spec without requiring specific extension strings.
 GL_EXPORT bool HasDesktopGLFeatures();
@@ -109,11 +118,15 @@ GL_EXPORT GLFunctionPointerType GetGLProcAddress(const char* name);
 // bindings themselves. This is a relatively expensive call, so
 // callers should cache the result.
 GL_EXPORT std::string GetGLExtensionsFromCurrentContext();
+GL_EXPORT std::string GetGLExtensionsFromCurrentContext(GLApi* api);
 
 // Helper for the GL bindings implementation to understand whether
 // glGetString(GL_EXTENSIONS) or glGetStringi(GL_EXTENSIONS, i) will
 // be used in the function above.
 GL_EXPORT bool WillUseGLGetStringForExtensions();
+GL_EXPORT bool WillUseGLGetStringForExtensions(GLApi* api);
+
+GL_EXPORT std::unique_ptr<GLVersionInfo> GetVersionInfoFromContext(GLApi* api);
 
 // Helpers to load a library and log error on failure.
 GL_EXPORT base::NativeLibrary LoadLibraryAndPrintError(
diff --git a/chromium/ui/gl/gl_osmesa_api_implementation.cc b/chromium/ui/gl/gl_osmesa_api_implementation.cc
index 2145711c3d8..081fc3208b2 100644
--- a/chromium/ui/gl/gl_osmesa_api_implementation.cc
+++ b/chromium/ui/gl/gl_osmesa_api_implementation.cc
@@ -6,7 +6,8 @@
 
 namespace gl {
 
-RealOSMESAApi* g_real_osmesa;
+RealOSMESAApi* g_real_osmesa = nullptr;
+DebugOSMESAApi* g_debug_osmesa = nullptr;
 
 void InitializeStaticGLBindingsOSMESA() {
   g_driver_osmesa.InitializeStaticBindings();
@@ -19,10 +20,17 @@ void InitializeStaticGLBindingsOSMESA() {
 }
 
 void InitializeDebugGLBindingsOSMESA() {
-  g_driver_osmesa.InitializeDebugBindings();
+  if (!g_debug_osmesa) {
+    g_debug_osmesa = new DebugOSMESAApi(g_real_osmesa);
+  }
+  g_current_osmesa_context = g_debug_osmesa;
 }
 
 void ClearBindingsOSMESA() {
+  if (g_debug_osmesa) {
+    delete g_debug_osmesa;
+    g_debug_osmesa = NULL;
+  }
   if (g_real_osmesa) {
     delete g_real_osmesa;
     g_real_osmesa = NULL;
@@ -58,6 +66,10 @@ void RealOSMESAApi::Initialize(DriverOSMESA* driver) {
   InitializeBase(driver);
 }
 
+DebugOSMESAApi::DebugOSMESAApi(OSMESAApi* osmesa_api)
+    : osmesa_api_(osmesa_api) {}
+DebugOSMESAApi::~DebugOSMESAApi() {}
+
 TraceOSMESAApi::~TraceOSMESAApi() {
 }
 
diff --git a/chromium/ui/gl/gl_osmesa_api_implementation.h b/chromium/ui/gl/gl_osmesa_api_implementation.h
index 92e5f5acfb8..6163b198def 100644
--- a/chromium/ui/gl/gl_osmesa_api_implementation.h
+++ b/chromium/ui/gl/gl_osmesa_api_implementation.h
@@ -37,6 +37,21 @@ class GL_EXPORT RealOSMESAApi : public OSMESAApiBase {
   void Initialize(DriverOSMESA* driver);
 };
 
+// Logs debug information for every OSMESA call.
+class GL_EXPORT DebugOSMESAApi : public OSMESAApi {
+ public:
+  DebugOSMESAApi(OSMESAApi* osmesa_api);
+  ~DebugOSMESAApi() override;
+
+  // 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_osmesa.h"
+
+ private:
+  OSMESAApi* osmesa_api_;
+};
+
 // Inserts a TRACE for every OSMESA call.
 class GL_EXPORT TraceOSMESAApi : public OSMESAApi {
  public:
diff --git a/chromium/ui/gl/gl_stub_api.cc b/chromium/ui/gl/gl_stub_api.cc
index 7d071cf8e90..5cdf6518b85 100644
--- a/chromium/ui/gl/gl_stub_api.cc
+++ b/chromium/ui/gl/gl_stub_api.cc
@@ -15,8 +15,7 @@ void GenHelper(GLsizei count, GLuint* objects) {
 
 }  // anonymous namespace
 
-GLStubApi::GLStubApi()
-    : version_("OpenGL ES 3.0"), extensions_("GL_EXT_framebuffer_object") {}
+GLStubApi::GLStubApi() {}
 
 GLStubApi::~GLStubApi() = default;
 
diff --git a/chromium/ui/gl/gl_surface.cc b/chromium/ui/gl/gl_surface.cc
index 70f2207150e..c0ac7f013cd 100644
--- a/chromium/ui/gl/gl_surface.cc
+++ b/chromium/ui/gl/gl_surface.cc
@@ -52,7 +52,7 @@ bool GLSurface::DeferDraws() {
   return false;
 }
 
-bool GLSurface::SupportsSwapBuffersWithDamage() {
+bool GLSurface::SupportsSwapBuffersWithBounds() {
   return false;
 }
 
@@ -76,10 +76,8 @@ void GLSurface::SwapBuffersAsync(const SwapCompletionCallback& callback) {
   NOTREACHED();
 }
 
-gfx::SwapResult GLSurface::SwapBuffersWithDamage(int x,
-                                                 int y,
-                                                 int width,
-                                                 int height) {
+gfx::SwapResult GLSurface::SwapBuffersWithBounds(
+    const std::vector<gfx::Rect>& rects) {
   return gfx::SwapResult::SWAP_FAILED;
 }
 
@@ -135,11 +133,6 @@ unsigned long GLSurface::GetCompatibilityKey() {
   return 0;
 }
 
-GLSurfaceFormat GLSurface::GetFormat() {
-  NOTIMPLEMENTED();
-  return GLSurfaceFormat();
-}
-
 gfx::VSyncProvider* GLSurface::GetVSyncProvider() {
   return NULL;
 }
@@ -175,6 +168,14 @@ bool GLSurface::BuffersFlipped() const {
   return false;
 }
 
+bool GLSurface::SupportsSetDrawRectangle() const {
+  return false;
+}
+
+bool GLSurface::SetDrawRectangle(const gfx::Rect& rect) {
+  return false;
+}
+
 GLSurface* GLSurface::GetCurrent() {
   return current_surface_.Pointer()->Get();
 }
@@ -241,11 +242,9 @@ void GLSurfaceAdapter::SwapBuffersAsync(
   surface_->SwapBuffersAsync(callback);
 }
 
-gfx::SwapResult GLSurfaceAdapter::SwapBuffersWithDamage(int x,
-                                                        int y,
-                                                        int width,
-                                                        int height) {
-  return surface_->SwapBuffersWithDamage(x, y, width, height);
+gfx::SwapResult GLSurfaceAdapter::SwapBuffersWithBounds(
+    const std::vector<gfx::Rect>& rects) {
+  return surface_->SwapBuffersWithBounds(rects);
 }
 
 gfx::SwapResult GLSurfaceAdapter::PostSubBuffer(int x,
@@ -273,8 +272,8 @@ void GLSurfaceAdapter::CommitOverlayPlanesAsync(
   surface_->CommitOverlayPlanesAsync(callback);
 }
 
-bool GLSurfaceAdapter::SupportsSwapBuffersWithDamage() {
-  return surface_->SupportsSwapBuffersWithDamage();
+bool GLSurfaceAdapter::SupportsSwapBuffersWithBounds() {
+  return surface_->SupportsSwapBuffersWithBounds();
 }
 
 bool GLSurfaceAdapter::SupportsPostSubBuffer() {
@@ -358,6 +357,18 @@ bool GLSurfaceAdapter::BuffersFlipped() const {
   return surface_->BuffersFlipped();
 }
 
+bool GLSurfaceAdapter::SupportsSetDrawRectangle() const {
+  return surface_->SupportsSetDrawRectangle();
+}
+
+bool GLSurfaceAdapter::SetDrawRectangle(const gfx::Rect& rect) {
+  return surface_->SetDrawRectangle(rect);
+}
+
+void GLSurfaceAdapter::OnSetSwapInterval(int interval) {
+  surface_->OnSetSwapInterval(interval);
+}
+
 GLSurfaceAdapter::~GLSurfaceAdapter() {}
 
 scoped_refptr<GLSurface> InitializeGLSurfaceWithFormat(
diff --git a/chromium/ui/gl/gl_surface.h b/chromium/ui/gl/gl_surface.h
index ce01dbc9e4a..1dee0591910 100644
--- a/chromium/ui/gl/gl_surface.h
+++ b/chromium/ui/gl/gl_surface.h
@@ -80,8 +80,8 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
   // Get the underlying platform specific surface "handle".
   virtual void* GetHandle() = 0;
 
-  // Returns whether or not the surface supports SwapBuffersWithDamage
-  virtual bool SupportsSwapBuffersWithDamage();
+  // Returns whether or not the surface supports SwapBuffersWithBounds
+  virtual bool SupportsSwapBuffersWithBounds();
 
   // Returns whether or not the surface supports PostSubBuffer.
   virtual bool SupportsPostSubBuffer();
@@ -104,11 +104,9 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
   // the calling thread (i.e. same thread SwapBuffersAsync is called)
   virtual void SwapBuffersAsync(const SwapCompletionCallback& callback);
 
-  // Swap buffers with damage rect.
-  virtual gfx::SwapResult SwapBuffersWithDamage(int x,
-                                                int y,
-                                                int width,
-                                                int height);
+  // Swap buffers with content bounds.
+  virtual gfx::SwapResult SwapBuffersWithBounds(
+      const std::vector<gfx::Rect>& rects);
 
   // Copy part of the backbuffer to the frontbuffer.
   virtual gfx::SwapResult PostSubBuffer(int x, int y, int width, int height);
@@ -159,8 +157,10 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
   // with this GLSurface.
   virtual unsigned long GetCompatibilityKey();
 
-  // Get the GL pixel format of the surface, if available.
-  virtual GLSurfaceFormat GetFormat();
+  // Get the GL pixel format of the surface. Must be implemented in a
+  // subclass, though it's ok to just "return GLSurfaceFormat()" if
+  // the default is appropriate.
+  virtual GLSurfaceFormat GetFormat() = 0;
 
   // Get access to a helper providing time of recent refresh and period
   // of screen refresh. If unavailable, returns NULL.
@@ -205,6 +205,11 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
   // the next buffer may be 2 frames old.
   virtual bool BuffersFlipped() const;
 
+  virtual bool SupportsSetDrawRectangle() const;
+
+  // Set the rectangle that will be drawn into on the surface.
+  virtual bool SetDrawRectangle(const gfx::Rect& rect);
+
   static GLSurface* GetCurrent();
 
   // Called when the swap interval for the associated context changes.
@@ -240,10 +245,8 @@ class GL_EXPORT GLSurfaceAdapter : public GLSurface {
   bool IsOffscreen() override;
   gfx::SwapResult SwapBuffers() override;
   void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
-  gfx::SwapResult SwapBuffersWithDamage(int x,
-                                        int y,
-                                        int width,
-                                        int height) override;
+  gfx::SwapResult SwapBuffersWithBounds(
+      const std::vector<gfx::Rect>& rects) override;
   gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   void PostSubBufferAsync(int x,
                           int y,
@@ -253,7 +256,7 @@ class GL_EXPORT GLSurfaceAdapter : public GLSurface {
   gfx::SwapResult CommitOverlayPlanes() override;
   void CommitOverlayPlanesAsync(
       const SwapCompletionCallback& callback) override;
-  bool SupportsSwapBuffersWithDamage() override;
+  bool SupportsSwapBuffersWithBounds() override;
   bool SupportsPostSubBuffer() override;
   bool SupportsCommitOverlayPlanes() override;
   bool SupportsAsyncSwap() override;
@@ -277,6 +280,9 @@ class GL_EXPORT GLSurfaceAdapter : public GLSurface {
   bool IsSurfaceless() const override;
   bool FlipsVertically() const override;
   bool BuffersFlipped() const override;
+  bool SupportsSetDrawRectangle() const override;
+  bool SetDrawRectangle(const gfx::Rect& rect) override;
+  void OnSetSwapInterval(int interval) override;
 
   GLSurface* surface() const { return surface_.get(); }
 
diff --git a/chromium/ui/gl/gl_surface_egl.cc b/chromium/ui/gl/gl_surface_egl.cc
index 1d5c1409980..9196ca0b094 100644
--- a/chromium/ui/gl/gl_surface_egl.cc
+++ b/chromium/ui/gl/gl_surface_egl.cc
@@ -31,6 +31,7 @@
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/scoped_make_current.h"
+#include "ui/gl/sync_control_vsync_provider.h"
 
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
 extern "C" {
@@ -136,9 +137,40 @@ bool g_egl_surfaceless_context_supported = false;
 bool g_egl_surface_orientation_supported = false;
 bool g_use_direct_composition = false;
 
-base::LazyInstance<ANGLEPlatformImpl> g_angle_platform_impl =
-    LAZY_INSTANCE_INITIALIZER;
-ANGLEPlatformShutdownFunc g_angle_platform_shutdown = nullptr;
+class EGLSyncControlVSyncProvider : public SyncControlVSyncProvider {
+ public:
+  explicit EGLSyncControlVSyncProvider(EGLSurface surface)
+      : SyncControlVSyncProvider(),
+        surface_(surface) {
+  }
+
+  ~EGLSyncControlVSyncProvider() override {}
+
+ protected:
+  bool GetSyncValues(int64_t* system_time,
+                     int64_t* media_stream_counter,
+                     int64_t* swap_buffer_counter) override {
+    uint64_t u_system_time, u_media_stream_counter, u_swap_buffer_counter;
+    bool result = eglGetSyncValuesCHROMIUM(
+        g_display, surface_, &u_system_time,
+        &u_media_stream_counter, &u_swap_buffer_counter) == EGL_TRUE;
+    if (result) {
+      *system_time = static_cast<int64_t>(u_system_time);
+      *media_stream_counter = static_cast<int64_t>(u_media_stream_counter);
+      *swap_buffer_counter = static_cast<int64_t>(u_swap_buffer_counter);
+    }
+    return result;
+  }
+
+  bool GetMscRate(int32_t* numerator, int32_t* denominator) override {
+    return false;
+  }
+
+ private:
+  EGLSurface surface_;
+
+  DISALLOW_COPY_AND_ASSIGN(EGLSyncControlVSyncProvider);
+};
 
 EGLDisplay GetPlatformANGLEDisplay(EGLNativeDisplayType native_display,
                                    EGLenum platform_type,
@@ -242,6 +274,7 @@ bool ValidateEglConfig(EGLDisplay display,
 EGLConfig ChooseConfig(GLSurfaceFormat format) {
   // Choose an EGL configuration.
   // On X this is only used for PBuffer surfaces.
+
   std::vector<EGLint> renderable_types;
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableES3GLContext)) {
@@ -252,6 +285,9 @@ EGLConfig ChooseConfig(GLSurfaceFormat format) {
   EGLint buffer_size = format.GetBufferSize();
   EGLint alpha_size = 8;
   bool want_rgb565 = buffer_size == 16;
+  EGLint depth_size = format.GetDepthBits();
+  EGLint stencil_size = format.GetStencilBits();
+  EGLint samples = format.GetSamples();
 
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
   // If we're using ANGLE_NULL, we may not have a display, in which case we
@@ -278,6 +314,12 @@ EGLConfig ChooseConfig(GLSurfaceFormat format) {
                                     8,
                                     EGL_RED_SIZE,
                                     8,
+                                    EGL_SAMPLES,
+                                    samples,
+                                    EGL_DEPTH_SIZE,
+                                    depth_size,
+                                    EGL_STENCIL_SIZE,
+                                    stencil_size,
                                     EGL_RENDERABLE_TYPE,
                                     renderable_type,
                                     EGL_SURFACE_TYPE,
@@ -292,6 +334,12 @@ EGLConfig ChooseConfig(GLSurfaceFormat format) {
                                    6,
                                    EGL_RED_SIZE,
                                    5,
+                                   EGL_SAMPLES,
+                                   samples,
+                                   EGL_DEPTH_SIZE,
+                                   depth_size,
+                                   EGL_STENCIL_SIZE,
+                                   stencil_size,
                                    EGL_RENDERABLE_TYPE,
                                    renderable_type,
                                    EGL_SURFACE_TYPE,
@@ -379,7 +427,7 @@ void GetEGLInitDisplays(bool supports_angle_d3d,
                         std::vector<DisplayType>* init_displays) {
   // SwiftShader does not use the platform extensions
   if (command_line->GetSwitchValueASCII(switches::kUseGL) ==
-      kGLImplementationSwiftShaderName) {
+      kGLImplementationSwiftShaderForWebGLName) {
     init_displays->push_back(SWIFT_SHADER);
     return;
   }
@@ -435,31 +483,6 @@ void GetEGLInitDisplays(bool supports_angle_d3d,
   }
 }
 
-EGLSyncControlVSyncProvider::EGLSyncControlVSyncProvider(EGLSurface surface)
-    : SyncControlVSyncProvider(), surface_(surface) {}
-
-EGLSyncControlVSyncProvider::~EGLSyncControlVSyncProvider() {}
-
-bool EGLSyncControlVSyncProvider::GetSyncValues(int64_t* system_time,
-                                                int64_t* media_stream_counter,
-                                                int64_t* swap_buffer_counter) {
-  uint64_t u_system_time, u_media_stream_counter, u_swap_buffer_counter;
-  bool result = eglGetSyncValuesCHROMIUM(g_display, surface_, &u_system_time,
-                                         &u_media_stream_counter,
-                                         &u_swap_buffer_counter) == EGL_TRUE;
-  if (result) {
-    *system_time = static_cast<int64_t>(u_system_time);
-    *media_stream_counter = static_cast<int64_t>(u_media_stream_counter);
-    *swap_buffer_counter = static_cast<int64_t>(u_swap_buffer_counter);
-  }
-  return result;
-}
-
-bool EGLSyncControlVSyncProvider::GetMscRate(int32_t* numerator,
-                                             int32_t* denominator) {
-  return false;
-}
-
 GLSurfaceEGL::GLSurfaceEGL() {}
 
 GLSurfaceFormat GLSurfaceEGL::GetFormat() {
@@ -549,9 +572,7 @@ bool GLSurfaceEGL::InitializeOneOff(EGLNativeDisplayType native_display) {
 
 // static
 void GLSurfaceEGL::ShutdownOneOff() {
-  if (g_angle_platform_shutdown) {
-    g_angle_platform_shutdown();
-  }
+  ResetANGLEPlatform(g_display);
 
   if (g_display != EGL_NO_DISPLAY)
     eglTerminate(g_display);
@@ -626,17 +647,6 @@ EGLDisplay GLSurfaceEGL::InitializeDisplay(
 
   g_native_display = native_display;
 
-  // Init ANGLE platform here, before we call GetPlatformDisplay().
-  ANGLEPlatformInitializeFunc angle_platform_init =
-      reinterpret_cast<ANGLEPlatformInitializeFunc>(
-          eglGetProcAddress("ANGLEPlatformInitialize"));
-  if (angle_platform_init) {
-    angle_platform_init(&g_angle_platform_impl.Get());
-
-    g_angle_platform_shutdown = reinterpret_cast<ANGLEPlatformShutdownFunc>(
-        eglGetProcAddress("ANGLEPlatformShutdown"));
-  }
-
   // If EGL_EXT_client_extensions not supported this call to eglQueryString
   // will return NULL.
   const char* client_extensions =
@@ -670,6 +680,13 @@ EGLDisplay GLSurfaceEGL::InitializeDisplay(
                  << GetLastEGLErrorString();
     }
 
+    // Init ANGLE platform now that we have the global display.
+    if (supports_angle_d3d || supports_angle_opengl || supports_angle_null) {
+      if (!InitializeANGLEPlatform(display)) {
+        LOG(ERROR) << "ANGLE Platform initialization failed.";
+      }
+    }
+
     if (!eglInitialize(display, nullptr, nullptr)) {
       bool is_last = disp_index == init_displays.size() - 1;
 
@@ -787,9 +804,7 @@ bool NativeViewGLSurfaceEGL::Initialize(
   }
 
   supports_swap_buffer_with_damage_ =
-      g_driver_egl.ext.b_EGL_KHR_swap_buffers_with_damage &&
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableSwapBuffersWithDamage);
+      g_driver_egl.ext.b_EGL_KHR_swap_buffers_with_damage;
 
   if (sync_provider)
     vsync_provider_ = std::move(sync_provider);
@@ -930,10 +945,6 @@ EGLSurface NativeViewGLSurfaceEGL::GetHandle() {
   return surface_;
 }
 
-bool NativeViewGLSurfaceEGL::SupportsSwapBuffersWithDamage() {
-  return supports_swap_buffer_with_damage_;
-}
-
 bool NativeViewGLSurfaceEGL::SupportsPostSubBuffer() {
   return supports_post_sub_buffer_;
 }
@@ -946,25 +957,18 @@ bool NativeViewGLSurfaceEGL::BuffersFlipped() const {
   return g_use_direct_composition;
 }
 
-gfx::SwapResult NativeViewGLSurfaceEGL::SwapBuffersWithDamage(int x,
-                                                              int y,
-                                                              int width,
-                                                              int height) {
+gfx::SwapResult NativeViewGLSurfaceEGL::SwapBuffersWithDamage(
+    const std::vector<int>& rects) {
   DCHECK(supports_swap_buffer_with_damage_);
   UpdateSwapInterval();
   if (!CommitAndClearPendingOverlays()) {
     DVLOG(1) << "Failed to commit pending overlay planes.";
     return gfx::SwapResult::SWAP_FAILED;
   }
-  if (flips_vertically_) {
-    // With EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE the contents are rendered
-    // inverted, but the damage rectangle is still measured from the
-    // bottom left.
-    y = GetSize().height() - y - height;
-  }
 
-  EGLint damage_rect[4] = {x, y, width, height};
-  if (!eglSwapBuffersWithDamageKHR(GetDisplay(), surface_, damage_rect, 1)) {
+  if (!eglSwapBuffersWithDamageKHR(GetDisplay(), surface_,
+                                   const_cast<EGLint*>(rects.data()),
+                                   static_cast<EGLint>(rects.size() / 4))) {
     DVLOG(1) << "eglSwapBuffersWithDamageKHR failed with error "
              << GetLastEGLErrorString();
     return gfx::SwapResult::SWAP_FAILED;
diff --git a/chromium/ui/gl/gl_surface_egl.h b/chromium/ui/gl/gl_surface_egl.h
index 6e003f88c48..d9caa8fe55b 100644
--- a/chromium/ui/gl/gl_surface_egl.h
+++ b/chromium/ui/gl/gl_surface_egl.h
@@ -24,7 +24,6 @@
 #include "ui/gl/gl_export.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_surface_overlay.h"
-#include "ui/gl/sync_control_vsync_provider.h"
 
 namespace gl {
 
@@ -48,25 +47,6 @@ GL_EXPORT void GetEGLInitDisplays(bool supports_angle_d3d,
                                   const base::CommandLine* command_line,
                                   std::vector<DisplayType>* init_displays);
 
-// VSync provider for EGL surface;
-class GL_EXPORT EGLSyncControlVSyncProvider : public SyncControlVSyncProvider {
- public:
-  explicit EGLSyncControlVSyncProvider(EGLSurface surface);
-  ~EGLSyncControlVSyncProvider() override;
-
- protected:
-  bool GetSyncValues(int64_t* system_time,
-                     int64_t* media_stream_counter,
-                     int64_t* swap_buffer_counter) override;
-
-  bool GetMscRate(int32_t* numerator, int32_t* denominator) override;
-
- private:
-  EGLSurface surface_;
-
-  DISALLOW_COPY_AND_ASSIGN(EGLSyncControlVSyncProvider);
-};
-
 // Interface for EGL surface.
 class GL_EXPORT GLSurfaceEGL : public GLSurface {
  public:
@@ -122,12 +102,7 @@ class GL_EXPORT NativeViewGLSurfaceEGL : public GLSurfaceEGL {
   gfx::SwapResult SwapBuffers() override;
   gfx::Size GetSize() override;
   EGLSurface GetHandle() override;
-  bool SupportsSwapBuffersWithDamage() override;
   bool SupportsPostSubBuffer() override;
-  gfx::SwapResult SwapBuffersWithDamage(int x,
-                                        int y,
-                                        int width,
-                                        int height) override;
   gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   bool SupportsCommitOverlayPlanes() override;
   gfx::SwapResult CommitOverlayPlanes() override;
@@ -155,6 +130,7 @@ class GL_EXPORT NativeViewGLSurfaceEGL : public GLSurfaceEGL {
   bool enable_fixed_size_angle_;
 
   void OnSetSwapInterval(int interval) override;
+  gfx::SwapResult SwapBuffersWithDamage(const std::vector<int>& rects);
 
  private:
   // Commit the |pending_overlays_| and clear the vector. Returns false if any
diff --git a/chromium/ui/gl/gl_surface_format.h b/chromium/ui/gl/gl_surface_format.h
index cb7d51d7baa..2fcf504f887 100644
--- a/chromium/ui/gl/gl_surface_format.h
+++ b/chromium/ui/gl/gl_surface_format.h
@@ -9,6 +9,10 @@
 
 namespace gl {
 
+// Expresses surface format properties that may vary depending
+// on the underlying gl_surface implementation or specific usage
+// scenarios. Intended usage is to support copying formats and
+// checking compatibility.
 class GL_EXPORT GLSurfaceFormat {
  public:
 
@@ -19,19 +23,36 @@ class GL_EXPORT GLSurfaceFormat {
     PIXEL_LAYOUT_RGBA,
   };
 
+  // Default surface format for the underlying gl_surface subtype.
+  // Use the setters below to change attributes if needed.
   GLSurfaceFormat();
 
-  ~GLSurfaceFormat();
-
+  // Use a specified pixel layout, cf. gl_surface_osmesa.
   GLSurfaceFormat(SurfacePixelLayout layout);
 
+  // Copy constructor from pre-existing format.
   GLSurfaceFormat(const GLSurfaceFormat& other);
 
+  ~GLSurfaceFormat();
+
+  // Helper method to determine if the format is unchanged from the
+  // default at creation time. TODO(klausw): can this be removed?
   bool IsDefault();
 
+  // Surfaceless appears as a format property for backwards
+  // compatibility with the previous enum-based implementation.
+  // TODO(klausw): consider removing it and/or merging it into the
+  // pre-existing IsSurfaceless() predicate for the various Surface
+  // subclasses?
   void SetIsSurfaceless();
   bool IsSurfaceless();
 
+  // A given pair of surfaces is considered compatible if glSetSurface
+  // can be used to switch between them without generating BAD_MATCH
+  // errors, visual errors, or gross inefficiency, and incompatible
+  // otherwise. For example, a pixel layout mismatch would be
+  // considered incompatible. This comparison only makes sense within
+  // the context of a single gl_surface subtype.
   bool IsCompatible(GLSurfaceFormat other_format);
 
   // Default pixel format is RGBA8888. Use this method to select
@@ -53,6 +74,9 @@ class GL_EXPORT GLSurfaceFormat {
 
   SurfacePixelLayout GetPixelLayout();
 
+  // Compute number of bits needed for storing one pixel, not
+  // including any padding. At this point mainly used to distinguish
+  // RGB565 (16) from RGBA8888 (32).
   int GetBufferSize();
 
  private:
diff --git a/chromium/ui/gl/gl_surface_glx.cc b/chromium/ui/gl/gl_surface_glx.cc
index 37ef1103c1f..d5f282dabb2 100644
--- a/chromium/ui/gl/gl_surface_glx.cc
+++ b/chromium/ui/gl/gl_surface_glx.cc
@@ -616,6 +616,10 @@ void* NativeViewGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
+GLSurfaceFormat NativeViewGLSurfaceGLX::GetFormat() {
+  return GLSurfaceFormat();
+}
+
 unsigned long NativeViewGLSurfaceGLX::GetCompatibilityKey() {
   return visual_id_;
 }
@@ -709,6 +713,10 @@ void* UnmappedNativeViewGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
+GLSurfaceFormat UnmappedNativeViewGLSurfaceGLX::GetFormat() {
+  return GLSurfaceFormat();
+}
+
 unsigned long UnmappedNativeViewGLSurfaceGLX::GetCompatibilityKey() {
   return XVisualIDFromVisual(g_visual);
 }
diff --git a/chromium/ui/gl/gl_surface_glx.h b/chromium/ui/gl/gl_surface_glx.h
index 3d2838ba1d0..7ab6b0aa6cf 100644
--- a/chromium/ui/gl/gl_surface_glx.h
+++ b/chromium/ui/gl/gl_surface_glx.h
@@ -72,6 +72,7 @@ class GL_EXPORT NativeViewGLSurfaceGLX : public GLSurfaceGLX {
   void* GetHandle() override;
   bool SupportsPostSubBuffer() override;
   void* GetConfig() override;
+  GLSurfaceFormat GetFormat() override;
   unsigned long GetCompatibilityKey() override;
   gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   gfx::VSyncProvider* GetVSyncProvider() override;
@@ -127,6 +128,7 @@ class GL_EXPORT UnmappedNativeViewGLSurfaceGLX : public GLSurfaceGLX {
   gfx::Size GetSize() override;
   void* GetHandle() override;
   void* GetConfig() override;
+  GLSurfaceFormat GetFormat() override;
   unsigned long GetCompatibilityKey() override;
 
  protected:
diff --git a/chromium/ui/gl/gl_surface_stub.cc b/chromium/ui/gl/gl_surface_stub.cc
index 9c94cb0da46..91cfbb27fb9 100644
--- a/chromium/ui/gl/gl_surface_stub.cc
+++ b/chromium/ui/gl/gl_surface_stub.cc
@@ -35,6 +35,10 @@ bool GLSurfaceStub::BuffersFlipped() const {
   return buffers_flipped_;
 }
 
+GLSurfaceFormat GLSurfaceStub::GetFormat() {
+  return GLSurfaceFormat();
+}
+
 GLSurfaceStub::~GLSurfaceStub() {}
 
 }  // namespace gl
diff --git a/chromium/ui/gl/gl_surface_stub.h b/chromium/ui/gl/gl_surface_stub.h
index 9d52a5c9181..860f989667c 100644
--- a/chromium/ui/gl/gl_surface_stub.h
+++ b/chromium/ui/gl/gl_surface_stub.h
@@ -26,6 +26,7 @@ class GL_EXPORT GLSurfaceStub : public GLSurface {
   gfx::Size GetSize() override;
   void* GetHandle() override;
   bool BuffersFlipped() const override;
+  GLSurfaceFormat GetFormat() override;
 
  protected:
   ~GLSurfaceStub() override;
diff --git a/chromium/ui/gl/gl_surface_wgl.cc b/chromium/ui/gl/gl_surface_wgl.cc
index a971b152210..eb48cc462e4 100644
--- a/chromium/ui/gl/gl_surface_wgl.cc
+++ b/chromium/ui/gl/gl_surface_wgl.cc
@@ -320,6 +320,10 @@ void* NativeViewGLSurfaceWGL::GetHandle() {
   return device_context_;
 }
 
+GLSurfaceFormat NativeViewGLSurfaceWGL::GetFormat() {
+  return GLSurfaceFormat();
+}
+
 PbufferGLSurfaceWGL::PbufferGLSurfaceWGL(const gfx::Size& size)
     : size_(size),
       device_context_(NULL),
@@ -394,4 +398,8 @@ void* PbufferGLSurfaceWGL::GetHandle() {
   return device_context_;
 }
 
+GLSurfaceFormat PbufferGLSurfaceWGL::GetFormat() {
+  return GLSurfaceFormat();
+}
+
 }  // namespace gl
diff --git a/chromium/ui/gl/gl_surface_wgl.h b/chromium/ui/gl/gl_surface_wgl.h
index 25990dff498..1396f059cef 100644
--- a/chromium/ui/gl/gl_surface_wgl.h
+++ b/chromium/ui/gl/gl_surface_wgl.h
@@ -47,6 +47,7 @@ class GL_EXPORT NativeViewGLSurfaceWGL : public GLSurfaceWGL {
   gfx::SwapResult SwapBuffers() override;
   gfx::Size GetSize() override;
   void* GetHandle() override;
+  GLSurfaceFormat GetFormat() override;
 
  private:
   ~NativeViewGLSurfaceWGL() override;
@@ -73,6 +74,7 @@ class GL_EXPORT PbufferGLSurfaceWGL : public GLSurfaceWGL {
   gfx::SwapResult SwapBuffers() override;
   gfx::Size GetSize() override;
   void* GetHandle() override;
+  GLSurfaceFormat GetFormat() override;
 
  private:
   ~PbufferGLSurfaceWGL() override;
diff --git a/chromium/ui/gl/gl_switches.cc b/chromium/ui/gl/gl_switches.cc
index dbf0e6e153e..2eccfc33dd3 100644
--- a/chromium/ui/gl/gl_switches.cc
+++ b/chromium/ui/gl/gl_switches.cc
@@ -13,7 +13,9 @@ const char kGLImplementationAppleName[]       = "apple";
 const char kGLImplementationEGLName[]         = "egl";
 const char kGLImplementationANGLEName[]       = "angle";
 const char kGLImplementationSwiftShaderName[] = "swiftshader";
+const char kGLImplementationSwiftShaderForWebGLName[] = "swiftshader-webgl";
 const char kGLImplementationMockName[]        = "mock";
+const char kGLImplementationStubName[] = "stub";
 
 const char kANGLEImplementationDefaultName[]  = "default";
 const char kANGLEImplementationD3D9Name[]     = "d3d9";
@@ -66,6 +68,7 @@ const char kUseANGLE[]                      = "use-angle";
 //  egl: whatever EGL / GLES2 the user has installed (Windows default - actually
 //       ANGLE).
 //  osmesa: The OSMesa software renderer.
+//  swiftshader: The SwiftShader software renderer.
 const char kUseGL[]                         = "use-gl";
 
 const char kSwiftShaderPath[]               = "swiftshader-path";
@@ -102,15 +105,15 @@ const char kEnableSgiVideoSync[] = "enable-sgi-video-sync";
 // the GL output will not be correct but tests will run faster.
 const char kDisableGLDrawingForTests[] = "disable-gl-drawing-for-tests";
 
-// Forces the use of OSMesa instead of hardware gpu.
-const char kOverrideUseGLWithOSMesaForTests[] =
-    "override-use-gl-with-osmesa-for-tests";
+// Forces the use of software GL instead of hardware gpu.
+const char kOverrideUseSoftwareGLForTests[] =
+    "override-use-software-gl-for-tests";
 
 // Disables specified comma separated GL Extensions if found.
 const char kDisableGLExtensions[] = "disable-gl-extensions";
 
-// Use EGL_KHR_swap_buffers_with_damage to implement PostSubBuffers
-const char kEnableSwapBuffersWithDamage[] = "enable-swap-buffers-with-damage";
+// Enables SwapBuffersWithBounds if it is supported.
+const char kEnableSwapBuffersWithBounds[] = "enable-swap-buffers-with-bounds";
 
 // This is the list of switches passed from this file that are passed from the
 // GpuProcessHost to the GPU Process. Add your switch to this list if you need
@@ -123,12 +126,22 @@ const char* kGLSwitchesCopiedFromGpuProcessHost[] = {
     kEnableSgiVideoSync,
     kGpuNoContextLost,
     kDisableGLDrawingForTests,
-    kOverrideUseGLWithOSMesaForTests,
+    kOverrideUseSoftwareGLForTests,
     kUseANGLE,
     kDisableDirectComposition,
-    kEnableSwapBuffersWithDamage,
+    kEnableSwapBuffersWithBounds,
 };
 const int kGLSwitchesCopiedFromGpuProcessHostNumSwitches =
     arraysize(kGLSwitchesCopiedFromGpuProcessHost);
 
 }  // namespace switches
+
+namespace features {
+
+#if defined(OS_WIN)
+// Wait for D3D VSync signals in GPU process (as opposed to delay based VSync
+// generated in Browser process based on VSync parameters).
+const base::Feature kD3DVsync{"D3DVsync", base::FEATURE_DISABLED_BY_DEFAULT};
+#endif  // defined(OS_WIN)
+
+}  // namespace features
diff --git a/chromium/ui/gl/gl_switches.h b/chromium/ui/gl/gl_switches.h
index 5edf397857a..945783b725a 100644
--- a/chromium/ui/gl/gl_switches.h
+++ b/chromium/ui/gl/gl_switches.h
@@ -7,6 +7,7 @@
 
 // Defines all the command-line switches used by ui/gl.
 
+#include "base/feature_list.h"
 #include "ui/gl/gl_export.h"
 
 namespace gl {
@@ -18,7 +19,9 @@ GL_EXPORT extern const char kGLImplementationAppleName[];
 GL_EXPORT extern const char kGLImplementationEGLName[];
 GL_EXPORT extern const char kGLImplementationANGLEName[];
 GL_EXPORT extern const char kGLImplementationSwiftShaderName[];
+GL_EXPORT extern const char kGLImplementationSwiftShaderForWebGLName[];
 extern const char kGLImplementationMockName[];
+extern const char kGLImplementationStubName[];
 
 GL_EXPORT extern const char kANGLEImplementationDefaultName[];
 GL_EXPORT extern const char kANGLEImplementationD3D9Name[];
@@ -51,15 +54,23 @@ GL_EXPORT extern const char kEnableES3APIs[];
 GL_EXPORT extern const char kDisableES3APIs[];
 GL_EXPORT extern const char kEnableSgiVideoSync[];
 GL_EXPORT extern const char kDisableGLExtensions[];
-GL_EXPORT extern const char kEnableSwapBuffersWithDamage[];
+GL_EXPORT extern const char kEnableSwapBuffersWithBounds[];
 
 // These flags are used by the test harness code, not passed in by users.
 GL_EXPORT extern const char kDisableGLDrawingForTests[];
-GL_EXPORT extern const char kOverrideUseGLWithOSMesaForTests[];
+GL_EXPORT extern const char kOverrideUseSoftwareGLForTests[];
 
 GL_EXPORT extern const char* kGLSwitchesCopiedFromGpuProcessHost[];
 GL_EXPORT extern const int kGLSwitchesCopiedFromGpuProcessHostNumSwitches;
 
 }  // namespace switches
 
+namespace features {
+
+#if defined(OS_WIN)
+GL_EXPORT extern const base::Feature kD3DVsync;
+#endif  // defined(OS_WIN)
+
+}  // namespace features
+
 #endif  // UI_GL_GL_SWITCHES_H_
diff --git a/chromium/ui/gl/gl_wgl_api_implementation.cc b/chromium/ui/gl/gl_wgl_api_implementation.cc
index c26312cdf9a..c6a500fc6d8 100644
--- a/chromium/ui/gl/gl_wgl_api_implementation.cc
+++ b/chromium/ui/gl/gl_wgl_api_implementation.cc
@@ -11,7 +11,8 @@
 
 namespace gl {
 
-RealWGLApi* g_real_wgl;
+RealWGLApi* g_real_wgl = nullptr;
+DebugWGLApi* g_debug_wgl = nullptr;
 
 void InitializeStaticGLBindingsWGL() {
   g_driver_wgl.InitializeStaticBindings();
@@ -24,10 +25,17 @@ void InitializeStaticGLBindingsWGL() {
 }
 
 void InitializeDebugGLBindingsWGL() {
-  g_driver_wgl.InitializeDebugBindings();
+  if (!g_debug_wgl) {
+    g_debug_wgl = new DebugWGLApi(g_real_wgl);
+  }
+  g_current_wgl_context = g_debug_wgl;
 }
 
 void ClearBindingsWGL() {
+  if (g_debug_wgl) {
+    delete g_debug_wgl;
+    g_debug_wgl = NULL;
+  }
   if (g_real_wgl) {
     delete g_real_wgl;
     g_real_wgl = NULL;
@@ -111,6 +119,10 @@ const char* RealWGLApi::wglGetExtensionsStringEXTFn() {
   return filtered_ext_exts_.c_str();
 }
 
+DebugWGLApi::DebugWGLApi(WGLApi* wgl_api) : wgl_api_(wgl_api) {}
+
+DebugWGLApi::~DebugWGLApi() {}
+
 TraceWGLApi::~TraceWGLApi() {
 }
 
diff --git a/chromium/ui/gl/gl_wgl_api_implementation.h b/chromium/ui/gl/gl_wgl_api_implementation.h
index 9366c636206..cc3628c15df 100644
--- a/chromium/ui/gl/gl_wgl_api_implementation.h
+++ b/chromium/ui/gl/gl_wgl_api_implementation.h
@@ -55,6 +55,21 @@ class GL_EXPORT RealWGLApi : public WGLApiBase {
   std::string filtered_ext_exts_;
 };
 
+// Logs debug information for every WGL call.
+class GL_EXPORT DebugWGLApi : public WGLApi {
+ public:
+  DebugWGLApi(WGLApi* wgl_api);
+  ~DebugWGLApi() override;
+
+  // 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_wgl.h"
+
+ private:
+  WGLApi* wgl_api_;
+};
+
 // Inserts a TRACE for every WGL call.
 class GL_EXPORT TraceWGLApi : public WGLApi {
  public:
diff --git a/chromium/ui/gl/gpu_timing_unittest.cc b/chromium/ui/gl/gpu_timing_unittest.cc
index c895a7dbbf7..6fa9b06f7e1 100644
--- a/chromium/ui/gl/gpu_timing_unittest.cc
+++ b/chromium/ui/gl/gpu_timing_unittest.cc
@@ -10,7 +10,7 @@
 
 #include "base/bind.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/gl/gl_context_stub_with_extensions.h"
+#include "ui/gl/gl_context_stub.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/gl_surface_stub.h"
@@ -54,8 +54,8 @@ class GPUTimingTest : public testing::Test {
     gl_.reset(new ::testing::StrictMock<MockGLInterface>());
     MockGLInterface::SetGLInterface(gl_.get());
 
-    context_ = new GLContextStubWithExtensions;
-    context_->AddExtensionsString(gl_extensions);
+    context_ = new GLContextStub;
+    context_->SetExtensionsString(gl_extensions);
     context_->SetGLVersionString(gl_version);
     surface_ = new GLSurfaceStub;
     context_->MakeCurrent(surface_.get());
@@ -81,7 +81,7 @@ class GPUTimingTest : public testing::Test {
   bool setup_ = false;
   bool cpu_time_bounded_ = false;
   std::unique_ptr<::testing::StrictMock<MockGLInterface>> gl_;
-  scoped_refptr<GLContextStubWithExtensions> context_;
+  scoped_refptr<GLContextStub> context_;
   scoped_refptr<GLSurfaceStub> surface_;
   GPUTimingFake gpu_timing_fake_queries_;
 };
diff --git a/chromium/ui/gl/init/gl_factory.cc b/chromium/ui/gl/init/gl_factory.cc
index dff751b2c79..20da613e0a6 100644
--- a/chromium/ui/gl/init/gl_factory.cc
+++ b/chromium/ui/gl/init/gl_factory.cc
@@ -29,16 +29,19 @@ bool InitializeGLOneOff() {
 
   // The default implementation is always the first one in list.
   GLImplementation impl = allowed_impls[0];
-  bool fallback_to_osmesa = false;
-  if (cmd->HasSwitch(switches::kOverrideUseGLWithOSMesaForTests)) {
-    impl = kGLImplementationOSMesaGL;
+  bool fallback_to_software_gl = false;
+  if (cmd->HasSwitch(switches::kOverrideUseSoftwareGLForTests)) {
+    impl = GetSoftwareGLImplementation();
   } else if (cmd->HasSwitch(switches::kUseGL)) {
     std::string requested_implementation_name =
         cmd->GetSwitchValueASCII(switches::kUseGL);
     if (requested_implementation_name == "any") {
-      fallback_to_osmesa = true;
+      fallback_to_software_gl = true;
     } else if (requested_implementation_name ==
-                   kGLImplementationSwiftShaderName ||
+               kGLImplementationSwiftShaderName) {
+      impl = kGLImplementationSwiftShaderGL;
+    } else if (requested_implementation_name ==
+                   kGLImplementationSwiftShaderForWebGLName ||
                requested_implementation_name == kGLImplementationANGLEName) {
       impl = kGLImplementationEGLGLES2;
     } else {
@@ -54,18 +57,18 @@ bool InitializeGLOneOff() {
   bool disable_gl_drawing = cmd->HasSwitch(switches::kDisableGLDrawingForTests);
 
   return InitializeGLOneOffImplementation(
-      impl, fallback_to_osmesa, gpu_service_logging, disable_gl_drawing);
+      impl, fallback_to_software_gl, gpu_service_logging, disable_gl_drawing);
 }
 
 bool InitializeGLOneOffImplementation(GLImplementation impl,
-                                      bool fallback_to_osmesa,
+                                      bool fallback_to_software_gl,
                                       bool gpu_service_logging,
                                       bool disable_gl_drawing) {
   bool initialized =
       InitializeStaticGLBindings(impl) && InitializeGLOneOffPlatform();
-  if (!initialized && fallback_to_osmesa) {
+  if (!initialized && fallback_to_software_gl) {
     ShutdownGL();
-    initialized = InitializeStaticGLBindings(kGLImplementationOSMesaGL) &&
+    initialized = InitializeStaticGLBindings(GetSoftwareGLImplementation()) &&
                   InitializeGLOneOffPlatform();
   }
   if (!initialized)
diff --git a/chromium/ui/gl/init/gl_factory.h b/chromium/ui/gl/init/gl_factory.h
index 4e62d2106a6..52dcbe1a074 100644
--- a/chromium/ui/gl/init/gl_factory.h
+++ b/chromium/ui/gl/init/gl_factory.h
@@ -5,6 +5,7 @@
 #ifndef UI_GL_INIT_GL_FACTORY_H_
 #define UI_GL_INIT_GL_FACTORY_H_
 
+#include <memory>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
@@ -15,6 +16,10 @@
 #include "ui/gl/gpu_preference.h"
 #include "ui/gl/init/gl_init_export.h"
 
+namespace gfx {
+class VSyncProvider;
+}  // namespace gfx
+
 namespace gl {
 
 class GLContext;
@@ -33,10 +38,11 @@ GL_INIT_EXPORT bool InitializeGLOneOff();
 
 // Initializes GL bindings using the provided parameters. This might be required
 // for use in tests, otherwise use InitializeGLOneOff() instead.
-GL_INIT_EXPORT bool InitializeGLOneOffImplementation(GLImplementation impl,
-                                                     bool fallback_to_osmesa,
-                                                     bool gpu_service_logging,
-                                                     bool disable_gl_drawing);
+GL_INIT_EXPORT bool InitializeGLOneOffImplementation(
+    GLImplementation impl,
+    bool fallback_to_software_gl,
+    bool gpu_service_logging,
+    bool disable_gl_drawing);
 
 // Clears GL bindings and resets GL implementation.
 GL_INIT_EXPORT void ShutdownGL();
@@ -58,6 +64,13 @@ GL_INIT_EXPORT scoped_refptr<GLContext> CreateGLContext(
 GL_INIT_EXPORT scoped_refptr<GLSurface> CreateViewGLSurface(
     gfx::AcceleratedWidget window);
 
+#if defined(OS_WIN)
+// Creates a GL surface that renders directly into a native window.
+GL_INIT_EXPORT scoped_refptr<GLSurface> CreateNativeViewGLSurfaceEGL(
+    gfx::AcceleratedWidget window,
+    std::unique_ptr<gfx::VSyncProvider> sync_provider);
+#endif
+
 #if defined(USE_OZONE)
 // Creates a GL surface that renders directly into a window with surfaceless
 // semantics - there is no default framebuffer and the primary surface must
diff --git a/chromium/ui/gl/init/gl_factory_android.cc b/chromium/ui/gl/init/gl_factory_android.cc
index e9c681f1cf7..91f728b3ce7 100644
--- a/chromium/ui/gl/init/gl_factory_android.cc
+++ b/chromium/ui/gl/init/gl_factory_android.cc
@@ -60,7 +60,7 @@ bool GLNonOwnedContext::Initialize(GLSurface* compatible_surface,
 }
 
 bool GLNonOwnedContext::MakeCurrent(GLSurface* surface) {
-  SetRealGLApi();
+  BindGLApi();
   SetCurrent(surface);
   InitializeDynamicBindings();
   return true;
@@ -99,6 +99,12 @@ scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group,
   switch (GetGLImplementation()) {
     case kGLImplementationMockGL:
       return scoped_refptr<GLContext>(new GLContextStub(share_group));
+    case kGLImplementationStubGL: {
+      scoped_refptr<GLContextStub> stub_context =
+          new GLContextStub(share_group);
+      stub_context->SetUseStubApi(true);
+      return stub_context;
+    }
     case kGLImplementationOSMesaGL:
       return InitializeGLContext(new GLContextOSMesa(share_group),
                                  compatible_surface, attribs);
@@ -152,6 +158,7 @@ scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat(
       }
     }
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
diff --git a/chromium/ui/gl/init/gl_factory_mac.cc b/chromium/ui/gl/init/gl_factory_mac.cc
index 1bcfbadd2e4..6716f4109df 100644
--- a/chromium/ui/gl/init/gl_factory_mac.cc
+++ b/chromium/ui/gl/init/gl_factory_mac.cc
@@ -43,6 +43,7 @@ class NoOpGLSurface : public GLSurface {
   void* GetHandle() override { return nullptr; }
   void* GetDisplay() override { return nullptr; }
   bool IsSurfaceless() const override { return true; }
+  GLSurfaceFormat GetFormat() override { return GLSurfaceFormat(); }
 
  protected:
   ~NoOpGLSurface() override {}
@@ -87,6 +88,12 @@ scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group,
                                  compatible_surface, attribs);
     case kGLImplementationMockGL:
       return new GLContextStub(share_group);
+    case kGLImplementationStubGL: {
+      scoped_refptr<GLContextStub> stub_context =
+          new GLContextStub(share_group);
+      stub_context->SetUseStubApi(true);
+      return stub_context;
+    }
     default:
       NOTREACHED();
       return nullptr;
@@ -106,6 +113,7 @@ scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) {
       return InitializeGLSurface(new GLSurfaceOSMesaHeadless());
     }
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
@@ -127,6 +135,7 @@ scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat(
       return InitializeGLSurfaceWithFormat(
           new NoOpGLSurface(size), format);
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
diff --git a/chromium/ui/gl/init/gl_factory_ozone.cc b/chromium/ui/gl/init/gl_factory_ozone.cc
index f2d1cbd9aaa..e47eaae26a3 100644
--- a/chromium/ui/gl/init/gl_factory_ozone.cc
+++ b/chromium/ui/gl/init/gl_factory_ozone.cc
@@ -7,19 +7,14 @@
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_context.h"
-#include "ui/gl/gl_context_egl.h"
 #include "ui/gl/gl_context_osmesa.h"
 #include "ui/gl/gl_context_stub.h"
-#include "ui/gl/gl_egl_api_implementation.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
-#include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/init/ozone_util.h"
-#include "ui/ozone/public/ozone_platform.h"
-#include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace gl {
 namespace init {
@@ -27,7 +22,8 @@ namespace init {
 namespace {
 
 bool HasDefaultImplementation(GLImplementation impl) {
-  return impl == kGLImplementationOSMesaGL || impl == kGLImplementationMockGL;
+  return impl == kGLImplementationOSMesaGL || impl == kGLImplementationMockGL ||
+         impl == kGLImplementationStubGL;
 }
 
 scoped_refptr<GLSurface> CreateDefaultViewGLSurface(
@@ -36,6 +32,7 @@ scoped_refptr<GLSurface> CreateDefaultViewGLSurface(
     case kGLImplementationOSMesaGL:
       return InitializeGLSurface(new GLSurfaceOSMesaHeadless());
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return InitializeGLSurface(new GLSurfaceStub());
     default:
       NOTREACHED();
@@ -51,6 +48,7 @@ scoped_refptr<GLSurface> CreateDefaultOffscreenGLSurface(
           new GLSurfaceOSMesa(
               GLSurfaceFormat(GLSurfaceFormat::PIXEL_LAYOUT_BGRA), size));
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return InitializeGLSurface(new GLSurfaceStub);
     default:
       NOTREACHED();
@@ -69,14 +67,7 @@ bool GetGLWindowSystemBindingInfo(GLWindowSystemBindingInfo* info) {
   if (HasGLOzone())
     return GetGLOzone()->GetGLWindowSystemBindingInfo(info);
 
-  // TODO(kylechar): This is deprecated and can be removed once all Ozone
-  // platforms use GLOzone instead.
-  switch (GetGLImplementation()) {
-    case kGLImplementationEGLGLES2:
-      return GetGLWindowSystemBindingInfoEGL(info);
-    default:
-      return false;
-  }
+  return false;
 }
 
 scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group,
@@ -92,12 +83,15 @@ scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group,
   switch (GetGLImplementation()) {
     case kGLImplementationMockGL:
       return scoped_refptr<GLContext>(new GLContextStub(share_group));
+    case kGLImplementationStubGL: {
+      scoped_refptr<GLContextStub> stub_context =
+          new GLContextStub(share_group);
+      stub_context->SetUseStubApi(true);
+      return stub_context;
+    }
     case kGLImplementationOSMesaGL:
       return InitializeGLContext(new GLContextOSMesa(share_group),
                                  compatible_surface, attribs);
-    case kGLImplementationEGLGLES2:
-      return InitializeGLContext(new GLContextEGL(share_group),
-                                 compatible_surface, attribs);
     default:
       NOTREACHED();
   }
@@ -113,10 +107,7 @@ scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) {
   if (HasDefaultImplementation(GetGLImplementation()))
     return CreateDefaultViewGLSurface(window);
 
-  // TODO(kylechar): This is deprecated and can be removed once all Ozone
-  // platforms use GLOzone instead.
-  return GetSurfaceFactoryOzone()->CreateViewGLSurface(GetGLImplementation(),
-                                                       window);
+  return nullptr;
 }
 
 scoped_refptr<GLSurface> CreateSurfacelessViewGLSurface(
@@ -126,10 +117,7 @@ scoped_refptr<GLSurface> CreateSurfacelessViewGLSurface(
   if (HasGLOzone())
     return GetGLOzone()->CreateSurfacelessViewGLSurface(window);
 
-  // TODO(kylechar): This is deprecated and can be removed once all Ozone
-  // platforms use GLOzone instead.
-  return GetSurfaceFactoryOzone()->CreateSurfacelessViewGLSurface(
-      GetGLImplementation(), window);
+  return nullptr;
 }
 
 scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat(
@@ -147,10 +135,7 @@ scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat(
   if (HasDefaultImplementation(GetGLImplementation()))
     return CreateDefaultOffscreenGLSurface(size);
 
-  // TODO(kylechar): This is deprecated and can be removed once all Ozone
-  // platforms use GLOzone instead.
-  return GetSurfaceFactoryOzone()->CreateOffscreenGLSurface(
-      GetGLImplementation(), size);
+  return nullptr;
 }
 
 }  // namespace init
diff --git a/chromium/ui/gl/init/gl_factory_win.cc b/chromium/ui/gl/init/gl_factory_win.cc
index 97760c45997..198147d3f57 100644
--- a/chromium/ui/gl/init/gl_factory_win.cc
+++ b/chromium/ui/gl/init/gl_factory_win.cc
@@ -31,6 +31,7 @@ std::vector<GLImplementation> GetAllowedGLImplementations() {
   impls.push_back(kGLImplementationEGLGLES2);
   impls.push_back(kGLImplementationDesktopGL);
   impls.push_back(kGLImplementationOSMesaGL);
+  impls.push_back(kGLImplementationSwiftShaderGL);
   return impls;
 }
 
@@ -53,6 +54,7 @@ scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group,
     case kGLImplementationOSMesaGL:
       return InitializeGLContext(new GLContextOSMesa(share_group),
                                  compatible_surface, attribs);
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       return InitializeGLContext(new GLContextEGL(share_group),
                                  compatible_surface, attribs);
@@ -61,6 +63,12 @@ scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group,
                                  compatible_surface, attribs);
     case kGLImplementationMockGL:
       return new GLContextStub(share_group);
+    case kGLImplementationStubGL: {
+      scoped_refptr<GLContextStub> stub_context =
+          new GLContextStub(share_group);
+      stub_context->SetUseStubApi(true);
+      return stub_context;
+    }
     default:
       NOTREACHED();
       return nullptr;
@@ -72,20 +80,16 @@ scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) {
   switch (GetGLImplementation()) {
     case kGLImplementationOSMesaGL:
       return InitializeGLSurface(new GLSurfaceOSMesaWin(window));
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2: {
-      DCHECK(window != gfx::kNullAcceleratedWidget);
-      scoped_refptr<NativeViewGLSurfaceEGL> surface(
-          new NativeViewGLSurfaceEGL(window));
-      std::unique_ptr<gfx::VSyncProvider> sync_provider;
-      sync_provider.reset(new VSyncProviderWin(window));
-      if (!surface->Initialize(std::move(sync_provider)))
-        return nullptr;
-
-      return surface;
+      std::unique_ptr<gfx::VSyncProvider> sync_provider(
+          new VSyncProviderWin(window));
+      return CreateNativeViewGLSurfaceEGL(window, std::move(sync_provider));
     }
     case kGLImplementationDesktopGL:
       return InitializeGLSurface(new NativeViewGLSurfaceWGL(window));
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
@@ -93,6 +97,21 @@ scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) {
   }
 }
 
+scoped_refptr<GLSurface> CreateNativeViewGLSurfaceEGL(
+    gfx::AcceleratedWidget window,
+    std::unique_ptr<gfx::VSyncProvider> sync_provider) {
+  DCHECK_EQ(kGLImplementationEGLGLES2, GetGLImplementation());
+  DCHECK(window != gfx::kNullAcceleratedWidget);
+
+  scoped_refptr<NativeViewGLSurfaceEGL> surface(
+      new NativeViewGLSurfaceEGL(window));
+
+  if (!surface->Initialize(std::move(sync_provider)))
+    return nullptr;
+
+  return surface;
+}
+
 scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat(
     const gfx::Size& size, GLSurfaceFormat format) {
   TRACE_EVENT0("gpu", "gl::init::CreateOffscreenGLSurface");
@@ -101,6 +120,7 @@ scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat(
       format.SetDefaultPixelLayout(GLSurfaceFormat::PIXEL_LAYOUT_RGBA);
       return InitializeGLSurfaceWithFormat(
           new GLSurfaceOSMesa(format, size), format);
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       return InitializeGLSurfaceWithFormat(
           new PbufferGLSurfaceEGL(size), format);
@@ -108,6 +128,7 @@ scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat(
       return InitializeGLSurfaceWithFormat(
           new PbufferGLSurfaceWGL(size), format);
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
diff --git a/chromium/ui/gl/init/gl_factory_x11.cc b/chromium/ui/gl/init/gl_factory_x11.cc
index ec3f1ada0e4..38a4d2210d6 100644
--- a/chromium/ui/gl/init/gl_factory_x11.cc
+++ b/chromium/ui/gl/init/gl_factory_x11.cc
@@ -31,6 +31,7 @@ std::vector<GLImplementation> GetAllowedGLImplementations() {
   impls.push_back(kGLImplementationDesktopGL);
   impls.push_back(kGLImplementationEGLGLES2);
   impls.push_back(kGLImplementationOSMesaGL);
+  impls.push_back(kGLImplementationSwiftShaderGL);
   return impls;
 }
 
@@ -56,11 +57,18 @@ scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group,
     case kGLImplementationDesktopGL:
       return InitializeGLContext(new GLContextGLX(share_group),
                                  compatible_surface, attribs);
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       return InitializeGLContext(new GLContextEGL(share_group),
                                  compatible_surface, attribs);
     case kGLImplementationMockGL:
       return new GLContextStub(share_group);
+    case kGLImplementationStubGL: {
+      scoped_refptr<GLContextStub> stub_context =
+          new GLContextStub(share_group);
+      stub_context->SetUseStubApi(true);
+      return stub_context;
+    }
     default:
       NOTREACHED();
       return nullptr;
@@ -74,10 +82,12 @@ scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) {
       return InitializeGLSurface(new GLSurfaceOSMesaX11(window));
     case kGLImplementationDesktopGL:
       return InitializeGLSurface(new GLSurfaceGLXX11(window));
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       DCHECK(window != gfx::kNullAcceleratedWidget);
       return InitializeGLSurface(new NativeViewGLSurfaceEGLX11(window));
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
@@ -96,10 +106,12 @@ scoped_refptr<GLSurface> CreateOffscreenGLSurfaceWithFormat(
     case kGLImplementationDesktopGL:
       return InitializeGLSurfaceWithFormat(
           new UnmappedNativeViewGLSurfaceGLX(size), format);
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       return InitializeGLSurfaceWithFormat(
           new PbufferGLSurfaceEGL(size), format);
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
diff --git a/chromium/ui/gl/init/gl_initializer_android.cc b/chromium/ui/gl/init/gl_initializer_android.cc
index f338cc0689f..7293e29f564 100644
--- a/chromium/ui/gl/init/gl_initializer_android.cc
+++ b/chromium/ui/gl/init/gl_initializer_android.cc
@@ -80,7 +80,8 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
     case kGLImplementationOSMesaGL:
       return InitializeStaticGLBindingsOSMesaGL();
     case kGLImplementationMockGL:
-      SetGLImplementation(kGLImplementationMockGL);
+    case kGLImplementationStubGL:
+      SetGLImplementation(implementation);
       InitializeStaticGLBindingsGL();
       return true;
     default:
diff --git a/chromium/ui/gl/init/gl_initializer_mac.cc b/chromium/ui/gl/init/gl_initializer_mac.cc
index 8e34502295c..a574fb9df48 100644
--- a/chromium/ui/gl/init/gl_initializer_mac.cc
+++ b/chromium/ui/gl/init/gl_initializer_mac.cc
@@ -163,7 +163,8 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
     case kGLImplementationAppleGL:
       return InitializeStaticCGLInternal(implementation);
     case kGLImplementationMockGL:
-      SetGLImplementation(kGLImplementationMockGL);
+    case kGLImplementationStubGL:
+      SetGLImplementation(implementation);
       InitializeStaticGLBindingsGL();
       return true;
     default:
diff --git a/chromium/ui/gl/init/gl_initializer_ozone.cc b/chromium/ui/gl/init/gl_initializer_ozone.cc
index 213ef8ba7a8..6e5fc67f8e8 100644
--- a/chromium/ui/gl/init/gl_initializer_ozone.cc
+++ b/chromium/ui/gl/init/gl_initializer_ozone.cc
@@ -6,47 +6,23 @@
 
 #include "base/logging.h"
 #include "ui/gl/gl_bindings.h"
-#include "ui/gl/gl_egl_api_implementation.h"
 #include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_implementation_osmesa.h"
 #include "ui/gl/gl_osmesa_api_implementation.h"
-#include "ui/gl/gl_surface_egl.h"
+#include "ui/gl/gl_surface.h"
 #include "ui/gl/init/ozone_util.h"
-#include "ui/ozone/public/ozone_platform.h"
-#include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace gl {
 namespace init {
 
-namespace {
-
-bool InitializeStaticEGLInternal() {
-  if (!GetSurfaceFactoryOzone()->LoadEGLGLES2Bindings())
-    return false;
-
-  SetGLImplementation(kGLImplementationEGLGLES2);
-  InitializeStaticGLBindingsGL();
-  InitializeStaticGLBindingsEGL();
-
-  return true;
-}
-
-}  // namespace
-
 bool InitializeGLOneOffPlatform() {
   if (HasGLOzone())
     return GetGLOzone()->InitializeGLOneOffPlatform();
 
   switch (GetGLImplementation()) {
-    case kGLImplementationEGLGLES2:
-      if (!GLSurfaceEGL::InitializeOneOff(
-              GetSurfaceFactoryOzone()->GetNativeDisplay())) {
-        LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
-        return false;
-      }
-      return true;
     case kGLImplementationOSMesaGL:
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       return true;
     default:
       return false;
@@ -67,10 +43,9 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
   switch (implementation) {
     case kGLImplementationOSMesaGL:
       return InitializeStaticGLBindingsOSMesaGL();
-    case kGLImplementationEGLGLES2:
-      return InitializeStaticEGLInternal();
     case kGLImplementationMockGL:
-      SetGLImplementation(kGLImplementationMockGL);
+    case kGLImplementationStubGL:
+      SetGLImplementation(implementation);
       InitializeStaticGLBindingsGL();
       return true;
     default:
@@ -86,19 +61,16 @@ void InitializeDebugGLBindings() {
     return;
   }
 
-  InitializeDebugGLBindingsEGL();
   InitializeDebugGLBindingsGL();
   InitializeDebugGLBindingsOSMESA();
 }
 
 void ShutdownGLPlatform() {
-  GLSurfaceEGL::ShutdownOneOff();
   if (HasGLOzone()) {
     GetGLOzone()->ShutdownGL();
     return;
   }
 
-  ClearBindingsEGL();
   ClearBindingsGL();
   ClearBindingsOSMESA();
 }
diff --git a/chromium/ui/gl/init/gl_initializer_win.cc b/chromium/ui/gl/init/gl_initializer_win.cc
index 89a3586dc1c..c8648a761c7 100644
--- a/chromium/ui/gl/init/gl_initializer_win.cc
+++ b/chromium/ui/gl/init/gl_initializer_win.cc
@@ -98,9 +98,11 @@ bool InitializeStaticEGLInternal() {
   base::FilePath gles_path;
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
+  const std::string use_gl =
+      command_line->GetSwitchValueASCII(switches::kUseGL);
   bool using_swift_shader =
-      command_line->GetSwitchValueASCII(switches::kUseGL) ==
-      kGLImplementationSwiftShaderName;
+      (use_gl == kGLImplementationSwiftShaderName) ||
+      (use_gl == kGLImplementationSwiftShaderForWebGLName);
   if (using_swift_shader) {
     if (!command_line->HasSwitch(switches::kSwiftShaderPath))
       return false;
@@ -242,6 +244,7 @@ bool InitializeGLOneOffPlatform() {
         return false;
       }
       break;
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       if (!GLSurfaceEGL::InitializeOneOff(GetDC(nullptr))) {
         LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
@@ -250,6 +253,7 @@ bool InitializeGLOneOffPlatform() {
       break;
     case kGLImplementationOSMesaGL:
     case kGLImplementationMockGL:
+    case kGLImplementationStubGL:
       break;
     default:
       NOTREACHED();
@@ -272,12 +276,14 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
   switch (implementation) {
     case kGLImplementationOSMesaGL:
       return InitializeStaticOSMesaInternal();
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       return InitializeStaticEGLInternal();
     case kGLImplementationDesktopGL:
       return InitializeStaticWGLInternal();
     case kGLImplementationMockGL:
-      SetGLImplementation(kGLImplementationMockGL);
+    case kGLImplementationStubGL:
+      SetGLImplementation(implementation);
       InitializeStaticGLBindingsGL();
       return true;
     default:
diff --git a/chromium/ui/gl/init/gl_initializer_x11.cc b/chromium/ui/gl/init/gl_initializer_x11.cc
index b8697bdb10b..2d88875feec 100644
--- a/chromium/ui/gl/init/gl_initializer_x11.cc
+++ b/chromium/ui/gl/init/gl_initializer_x11.cc
@@ -39,6 +39,9 @@ const char kEGLLibraryName[] = "libEGL.so.1";
 const char kGLESv2ANGLELibraryName[] = "libGLESv2.so";
 const char kEGLANGLELibraryName[] = "libEGL.so";
 
+const char kGLESv2SwiftShaderLibraryName[] = "libGLESv2.so";
+const char kEGLSwiftShaderLibraryName[] = "libEGL.so";
+
 bool InitializeStaticGLXInternal() {
   base::NativeLibrary library = NULL;
   const base::CommandLine* command_line =
@@ -89,6 +92,15 @@ bool InitializeStaticEGLInternal() {
 
     glesv2_path = module_path.Append(kGLESv2ANGLELibraryName);
     egl_path = module_path.Append(kEGLANGLELibraryName);
+  } else if (command_line->GetSwitchValueASCII(switches::kUseGL) ==
+             kGLImplementationSwiftShaderName) {
+    base::FilePath module_path;
+    if (!command_line->HasSwitch(switches::kSwiftShaderPath))
+      return false;
+    module_path = command_line->GetSwitchValuePath(switches::kSwiftShaderPath);
+
+    glesv2_path = module_path.Append(kGLESv2SwiftShaderLibraryName);
+    egl_path = module_path.Append(kEGLSwiftShaderLibraryName);
   }
 
   base::NativeLibrary gles_library = LoadLibraryAndPrintError(glesv2_path);
@@ -143,6 +155,7 @@ bool InitializeGLOneOffPlatform() {
         return false;
       }
       return true;
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       if (!GLSurfaceEGL::InitializeOneOff(gfx::GetXDisplay())) {
         LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
@@ -171,10 +184,12 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
       return InitializeStaticGLBindingsOSMesaGL();
     case kGLImplementationDesktopGL:
       return InitializeStaticGLXInternal();
+    case kGLImplementationSwiftShaderGL:
     case kGLImplementationEGLGLES2:
       return InitializeStaticEGLInternal();
     case kGLImplementationMockGL:
-      SetGLImplementation(kGLImplementationMockGL);
+    case kGLImplementationStubGL:
+      SetGLImplementation(implementation);
       InitializeStaticGLBindingsGL();
       return true;
     default:
diff --git a/chromium/ui/gl/scoped_api.cc b/chromium/ui/gl/scoped_api.cc
deleted file mode 100644
index 99e92da4528..00000000000
--- a/chromium/ui/gl/scoped_api.cc
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2015 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/scoped_api.h"
-
-#include "ui/gl/gl_gl_api_implementation.h"
-
-namespace gl {
-
-ScopedSetGLToRealGLApi::ScopedSetGLToRealGLApi()
-    : old_gl_api_(GetCurrentGLApi()) {
-  SetGLToRealGLApi();
-}
-
-ScopedSetGLToRealGLApi::~ScopedSetGLToRealGLApi() {
-  SetGLApi(old_gl_api_);
-}
-
-}  // namespace gl
diff --git a/chromium/ui/gl/scoped_api.h b/chromium/ui/gl/scoped_api.h
deleted file mode 100644
index 4d35f3d8475..00000000000
--- a/chromium/ui/gl/scoped_api.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2015 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_SCOPED_API_H_
-#define UI_GL_SCOPED_API_H_
-
-#include "base/macros.h"
-#include "ui/gl/gl_export.h"
-
-namespace gl {
-
-class GLApi;
-
-class GL_EXPORT ScopedSetGLToRealGLApi {
- public:
-  ScopedSetGLToRealGLApi();
-  ~ScopedSetGLToRealGLApi();
-
- private:
-  GLApi* old_gl_api_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedSetGLToRealGLApi);
-};
-
-}  // namespace gl
-
-#endif  // UI_GL_SCOPED_API_H_
diff --git a/chromium/ui/gl/sync_control_vsync_provider.cc b/chromium/ui/gl/sync_control_vsync_provider.cc
index e181d70eb17..f9dc5c56e47 100644
--- a/chromium/ui/gl/sync_control_vsync_provider.cc
+++ b/chromium/ui/gl/sync_control_vsync_provider.cc
@@ -11,7 +11,7 @@
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 
-#if defined(OS_LINUX) || defined(OS_WIN)
+#if defined(OS_LINUX)
 // These constants define a reasonable range for a calculated refresh interval.
 // Calculating refreshes out of this range will be considered a fatal error.
 const int64_t kMinVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 400;
@@ -21,17 +21,17 @@ const int64_t kMaxVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 10;
 // we think the latest computed interval is invalid (noisey due to
 // monitor configuration change, moving a window between monitors, etc.).
 const double kRelativeIntervalDifferenceThreshold = 0.05;
-#endif  // defined(OS_LINUX) || defined(OS_WIN)
+#endif
 
 namespace gl {
 
 SyncControlVSyncProvider::SyncControlVSyncProvider() : gfx::VSyncProvider() {
-#if defined(OS_LINUX) || defined(OS_WIN)
+#if defined(OS_LINUX)
   // On platforms where we can't get an accurate reading on the refresh
   // rate we fall back to the assumption that we're displaying 60 frames
   // per second.
   last_good_interval_ = base::TimeDelta::FromSeconds(1) / 60;
-#endif  // defined(OS_LINUX) || defined(OS_WIN)
+#endif
 }
 
 SyncControlVSyncProvider::~SyncControlVSyncProvider() {}
@@ -39,121 +39,33 @@ SyncControlVSyncProvider::~SyncControlVSyncProvider() {}
 void SyncControlVSyncProvider::GetVSyncParameters(
     const UpdateVSyncCallback& callback) {
   TRACE_EVENT0("gpu", "SyncControlVSyncProvider::GetVSyncParameters");
-#if defined(OS_LINUX) || defined(OS_WIN)
+#if defined(OS_LINUX)
   base::TimeTicks timebase;
 
+  // The actual clock used for the system time returned by glXGetSyncValuesOML
+  // is unspecified. In practice, the clock used is likely to be either
+  // CLOCK_REALTIME or CLOCK_MONOTONIC, so we compare the returned time to the
+  // current time according to both clocks, and assume that the returned time
+  // was produced by the clock whose current time is closest to it, subject
+  // to the restriction that the returned time must not be in the future
+  // (since it is the time of a vblank that has already occurred).
   int64_t system_time;
   int64_t media_stream_counter;
   int64_t swap_buffer_counter;
   if (!GetSyncValues(&system_time, &media_stream_counter, &swap_buffer_counter))
     return;
 
-  if (media_stream_counter == last_media_stream_counter_) {
-    // SyncValues haven't updated, there is no reason to invoke the callback.
-    return;
-  }
-
-  // Perform platform specific adjustment of |system_time| and
-  // |media_stream_counter|.
-  if (!AdjustSyncValues(&system_time, &media_stream_counter))
-    return;
-
-  timebase = base::TimeTicks::FromInternalValue(system_time);
-
-  // Only need the previous calculated interval for our filtering.
-  while (last_computed_intervals_.size() > 1)
-    last_computed_intervals_.pop();
-
-  base::TimeDelta timebase_diff;
-  int64_t counter_diff = 0;
-
-  int32_t numerator, denominator;
-  if (GetMscRate(&numerator, &denominator) && numerator) {
-    timebase_diff = base::TimeDelta::FromSeconds(denominator);
-    counter_diff = numerator;
-  } else if (!last_timebase_.is_null()) {
-    timebase_diff = timebase - last_timebase_;
-    counter_diff = media_stream_counter - last_media_stream_counter_;
-  }
-
-  if (counter_diff > 0 && timebase_diff > base::TimeDelta()) {
-    last_computed_intervals_.push(timebase_diff / counter_diff);
-
-    if (last_computed_intervals_.size() == 2) {
-      const base::TimeDelta& old_interval = last_computed_intervals_.front();
-      const base::TimeDelta& new_interval = last_computed_intervals_.back();
-
-      double relative_change = fabs(old_interval.InMillisecondsF() -
-                                    new_interval.InMillisecondsF()) /
-                               new_interval.InMillisecondsF();
-      if (relative_change < kRelativeIntervalDifferenceThreshold) {
-        if (new_interval.InMicroseconds() < kMinVsyncIntervalUs ||
-            new_interval.InMicroseconds() > kMaxVsyncIntervalUs) {
-#if defined(OS_WIN) || defined(USE_ASH)
-          // On ash platforms (ChromeOS essentially), the real refresh interval
-          // is queried from XRandR, regardless of the value calculated here,
-          // and this value is overriden by ui::CompositorVSyncManager.  The log
-          // should not be fatal in this case. Reconsider all this when XRandR
-          // support is added to non-ash platforms.
-          // http://crbug.com/340851
-          // On Windows |system_time| is based on QPC and it seems it may
-          // produce invalid value after a suspend/resume cycle.
-          // http://crbug.com/656469
-          LOG(ERROR)
-#else
-          LOG(FATAL)
-#endif  // OS_WIN || USE_ASH
-              << "Calculated bogus refresh interval="
-              << new_interval.InMicroseconds()
-              << " us, old_interval=" << old_interval.InMicroseconds()
-              << " us, last_timebase_=" << last_timebase_.ToInternalValue()
-              << " us, timebase=" << timebase.ToInternalValue()
-              << " us, timebase_diff=" << timebase_diff.ToInternalValue()
-              << " us, last_timebase_diff_="
-              << last_timebase_diff_.ToInternalValue()
-              << " us, last_media_stream_counter_="
-              << last_media_stream_counter_
-              << ", media_stream_counter=" << media_stream_counter
-              << ", counter_diff=" << counter_diff
-              << ", last_counter_diff_=" << last_counter_diff_;
-        } else {
-          last_good_interval_ = new_interval;
-        }
-      }
-    }
-
-    last_timebase_diff_ = timebase_diff;
-    last_counter_diff_ = counter_diff;
-  }
-
-  last_timebase_ = timebase;
-  last_media_stream_counter_ = media_stream_counter;
-  callback.Run(timebase, last_good_interval_);
-#endif  // defined(OS_LINUX) || defined(OS_WIN)
-}
-
-#if defined(OS_LINUX)
-bool SyncControlVSyncProvider::AdjustSyncValues(int64_t* system_time,
-                                                int64_t* media_stream_counter) {
   // Both Intel and Mali drivers will return TRUE for GetSyncValues
   // but a value of 0 for MSC if they cannot access the CRTC data structure
   // associated with the surface. crbug.com/231945
   bool prev_invalid_msc = invalid_msc_;
-  invalid_msc_ = (*media_stream_counter == 0);
+  invalid_msc_ = (media_stream_counter == 0);
   if (invalid_msc_) {
-    LOG_IF(ERROR, !prev_invalid_msc)
-        << "glXGetSyncValuesOML "
-           "should not return TRUE with a media stream counter of 0.";
-    return false;
+    LOG_IF(ERROR, !prev_invalid_msc) << "glXGetSyncValuesOML "
+        "should not return TRUE with a media stream counter of 0.";
+    return;
   }
 
-  // The actual clock used for the system time returned by glXGetSyncValuesOML
-  // is unspecified. In practice, the clock used is likely to be either
-  // CLOCK_REALTIME or CLOCK_MONOTONIC, so we compare the returned time to the
-  // current time according to both clocks, and assume that the returned time
-  // was produced by the clock whose current time is closest to it, subject
-  // to the restriction that the returned time must not be in the future
-  // (since it is the time of a vblank that has already occurred).
   struct timespec real_time;
   struct timespec monotonic_time;
   clock_gettime(CLOCK_REALTIME, &real_time);
@@ -169,62 +81,81 @@ bool SyncControlVSyncProvider::AdjustSyncValues(int64_t* system_time,
   // We need the time according to CLOCK_MONOTONIC, so if we've been given
   // a time from CLOCK_REALTIME, we need to convert.
   bool time_conversion_needed =
-      llabs(*system_time - real_time_in_microseconds) <
-      llabs(*system_time - monotonic_time_in_microseconds);
+      llabs(system_time - real_time_in_microseconds) <
+      llabs(system_time - monotonic_time_in_microseconds);
 
   if (time_conversion_needed)
-    *system_time += monotonic_time_in_microseconds - real_time_in_microseconds;
+    system_time += monotonic_time_in_microseconds - real_time_in_microseconds;
 
-  // Return if |*system_time| is more than 1 frames in the future.
+  // Return if |system_time| is more than 1 frames in the future.
   int64_t interval_in_microseconds = last_good_interval_.InMicroseconds();
-  if (*system_time > monotonic_time_in_microseconds + interval_in_microseconds)
-    return false;
+  if (system_time > monotonic_time_in_microseconds + interval_in_microseconds)
+    return;
 
   // If |system_time| is slightly in the future, adjust it to the previous
   // frame and use the last frame counter to prevent issues in the callback.
-  if (*system_time > monotonic_time_in_microseconds) {
-    *system_time -= interval_in_microseconds;
-    (*media_stream_counter)--;
+  if (system_time > monotonic_time_in_microseconds) {
+    system_time -= interval_in_microseconds;
+    media_stream_counter--;
   }
-  if (monotonic_time_in_microseconds - *system_time >
+  if (monotonic_time_in_microseconds - system_time >
       base::Time::kMicrosecondsPerSecond)
-    return false;
+    return;
 
-  return true;
-}
-#endif  // defined(OS_LINUX)
+  timebase = base::TimeTicks::FromInternalValue(system_time);
 
-#if defined(OS_WIN)
-bool SyncControlVSyncProvider::AdjustSyncValues(int64_t* system_time,
-                                                int64_t* media_stream_counter) {
-  // Zero MSC is returned once when switching between windowed and full screen
-  // modes.
-  if (*media_stream_counter == 0)
-    return false;
-
-  // The actual clock used for the system time returned by glXGetSyncValuesEGL
-  // is unspecified. In practice, the clock comes from QueryPerformanceCounter.
-  LARGE_INTEGER perf_counter_now = {};
-  ::QueryPerformanceCounter(&perf_counter_now);
-  int64_t qpc_now =
-      base::TimeDelta::FromQPCValue(perf_counter_now.QuadPart).InMicroseconds();
+  // Only need the previous calculated interval for our filtering.
+  while (last_computed_intervals_.size() > 1)
+    last_computed_intervals_.pop();
 
-  // Return if |system_time| is more than 1 frames in the future.
-  int64_t interval_in_microseconds = last_good_interval_.InMicroseconds();
-  if (*system_time > qpc_now + interval_in_microseconds)
-    return false;
+  int32_t numerator, denominator;
+  if (GetMscRate(&numerator, &denominator) && numerator) {
+    last_computed_intervals_.push(base::TimeDelta::FromSeconds(denominator) /
+                                  numerator);
+  } else if (!last_timebase_.is_null()) {
+    base::TimeDelta timebase_diff = timebase - last_timebase_;
+    int64_t counter_diff = media_stream_counter - last_media_stream_counter_;
+    if (counter_diff > 0 && timebase > last_timebase_)
+      last_computed_intervals_.push(timebase_diff / counter_diff);
+  }
 
-  // If |system_time| is slightly in the future, adjust it to the previous
-  // frame and use the last frame counter to prevent issues in the callback.
-  if (*system_time > qpc_now) {
-    *system_time -= interval_in_microseconds;
-    (*media_stream_counter)--;
+  if (last_computed_intervals_.size() == 2) {
+    const base::TimeDelta& old_interval = last_computed_intervals_.front();
+    const base::TimeDelta& new_interval = last_computed_intervals_.back();
+
+    double relative_change =
+        fabs(old_interval.InMillisecondsF() - new_interval.InMillisecondsF()) /
+        new_interval.InMillisecondsF();
+    if (relative_change < kRelativeIntervalDifferenceThreshold) {
+      if (new_interval.InMicroseconds() < kMinVsyncIntervalUs ||
+          new_interval.InMicroseconds() > kMaxVsyncIntervalUs) {
+#if defined(USE_ASH)
+        // On ash platforms (ChromeOS essentially), the real refresh interval is
+        // queried from XRandR, regardless of the value calculated here, and
+        // this value is overriden by ui::CompositorVSyncManager.  The log
+        // should not be fatal in this case. Reconsider all this when XRandR
+        // support is added to non-ash platforms.
+        // http://crbug.com/340851
+        LOG(ERROR)
+#else
+        LOG(FATAL)
+#endif  // USE_ASH
+            << "Calculated bogus refresh interval="
+            << new_interval.InMicroseconds()
+            << " us., last_timebase_=" << last_timebase_.ToInternalValue()
+            << " us., timebase=" << timebase.ToInternalValue()
+            << " us., last_media_stream_counter_=" << last_media_stream_counter_
+            << ", media_stream_counter=" << media_stream_counter;
+      } else {
+        last_good_interval_ = new_interval;
+      }
+    }
   }
-  if (qpc_now - *system_time > base::Time::kMicrosecondsPerSecond)
-    return false;
 
-  return true;
+  last_timebase_ = timebase;
+  last_media_stream_counter_ = media_stream_counter;
+  callback.Run(timebase, last_good_interval_);
+#endif  // defined(OS_LINUX)
 }
-#endif  // defined(OS_WIN)
 
 }  // namespace gl
diff --git a/chromium/ui/gl/sync_control_vsync_provider.h b/chromium/ui/gl/sync_control_vsync_provider.h
index 19d4a33bf21..9e196538e03 100644
--- a/chromium/ui/gl/sync_control_vsync_provider.h
+++ b/chromium/ui/gl/sync_control_vsync_provider.h
@@ -11,13 +11,12 @@
 
 #include "base/macros.h"
 #include "ui/gfx/vsync_provider.h"
-#include "ui/gl/gl_export.h"
 
 namespace gl {
 
 // Base class for providers based on extensions like GLX_OML_sync_control and
 // EGL_CHROMIUM_sync_control.
-class GL_EXPORT SyncControlVSyncProvider : public gfx::VSyncProvider {
+class SyncControlVSyncProvider : public gfx::VSyncProvider {
  public:
   SyncControlVSyncProvider();
   ~SyncControlVSyncProvider() override;
@@ -32,24 +31,17 @@ class GL_EXPORT SyncControlVSyncProvider : public gfx::VSyncProvider {
   virtual bool GetMscRate(int32_t* numerator, int32_t* denominator) = 0;
 
  private:
-#if defined(OS_LINUX) || defined(OS_WIN)
-  bool AdjustSyncValues(int64_t* system_time, int64_t* media_stream_counter);
-
+#if defined(OS_LINUX)
   base::TimeTicks last_timebase_;
-  base::TimeDelta last_timebase_diff_;
-  int64_t last_media_stream_counter_ = 0;
-  int64_t last_counter_diff_ = 0;
+  uint64_t last_media_stream_counter_ = 0;
   base::TimeDelta last_good_interval_;
+  bool invalid_msc_ = false;
 
   // A short history of the last few computed intervals.
   // We use this to filter out the noise in the computation resulting
   // from configuration change (monitor reconfiguration, moving windows
   // between monitors, suspend and resume, etc.).
   std::queue<base::TimeDelta> last_computed_intervals_;
-#endif  //  defined(OS_LINUX) || defined(OS_WIN)
-
-#if defined(OS_LINUX)
-  bool invalid_msc_ = false;
 #endif  // defined(OS_LINUX)
 
   DISALLOW_COPY_AND_ASSIGN(SyncControlVSyncProvider);
diff --git a/chromium/ui/gl/vsync_provider_win.h b/chromium/ui/gl/vsync_provider_win.h
index 8435fba662c..2a042a08b5f 100644
--- a/chromium/ui/gl/vsync_provider_win.h
+++ b/chromium/ui/gl/vsync_provider_win.h
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef UI_GL_VSYNC_PROVIDER_WIN_H_
+#define UI_GL_VSYNC_PROVIDER_WIN_H_
+
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gl/gl_export.h"
@@ -25,3 +28,5 @@ class GL_EXPORT VSyncProviderWin : public gfx::VSyncProvider {
 };
 
 }  // namespace gl
+
+#endif  // UI_GL_VSYNC_PROVIDER_WIN_H_
diff --git a/chromium/ui/gl/yuv_to_rgb_converter.cc b/chromium/ui/gl/yuv_to_rgb_converter.cc
index faf29b67f89..1cb715d2bf1 100644
--- a/chromium/ui/gl/yuv_to_rgb_converter.cc
+++ b/chromium/ui/gl/yuv_to_rgb_converter.cc
@@ -8,7 +8,6 @@
 #include "base/strings/stringprintf.h"
 #include "ui/gl/gl_helper.h"
 #include "ui/gl/gl_version_info.h"
-#include "ui/gl/scoped_api.h"
 #include "ui/gl/scoped_binders.h"
 
 namespace gl {
@@ -72,7 +71,6 @@ STRINGIZE(
 
 YUVToRGBConverter::YUVToRGBConverter(const GLVersionInfo& gl_version_info) {
   bool use_core_profile = gl_version_info.is_desktop_core_profile;
-  ScopedSetGLToRealGLApi scoped_set_gl_api;
   glGenFramebuffersEXT(1, &framebuffer_);
   vertex_buffer_ = GLHelper::SetupQuadVertexBuffer();
   vertex_shader_ = GLHelper::LoadShader(
@@ -107,7 +105,6 @@ YUVToRGBConverter::YUVToRGBConverter(const GLVersionInfo& gl_version_info) {
 }
 
 YUVToRGBConverter::~YUVToRGBConverter() {
-  ScopedSetGLToRealGLApi scoped_set_gl_api;
   glDeleteTextures(1, &y_texture_);
   glDeleteTextures(1, &uv_texture_);
   glDeleteProgram(program_);
@@ -120,8 +117,6 @@ YUVToRGBConverter::~YUVToRGBConverter() {
 void YUVToRGBConverter::CopyYUV420ToRGB(unsigned target,
                                         const gfx::Size& size,
                                         unsigned rgb_texture) {
-  ScopedSetGLToRealGLApi scoped_set_gl_api;
-
   // Note that state restoration is done explicitly instead of scoped binders to
   // avoid https://crbug.com/601729.
   GLint old_active_texture = -1;