BASELINE: Update Chromium to 47.0.2526.14

Also adding in sources needed for spellchecking.

Change-Id: Idd44170fa1616f26315188970a8d5ba7d472b18a
Reviewed-by: Michael Brüning <michael.bruning@theqtcompany.com>

80 files changed, 4711 insertions, 3900 deletions

diff --git a/chromium/ui/gl/BUILD.gn b/chromium/ui/gl/BUILD.gn
index f5f4134290b..c63b290d2a2 100644
--- a/chromium/ui/gl/BUILD.gn
+++ b/chromium/ui/gl/BUILD.gn
@@ -96,14 +96,19 @@ 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",
     "scoped_make_current.h",
     "sync_control_vsync_provider.cc",
     "sync_control_vsync_provider.h",
+    "trace_util.cc",
+    "trace_util.h",
   ]
 
+  configs += [ "//build/config:precompiled_headers" ]
   defines = [ "GL_IMPLEMENTATION" ]
 
   include_dirs = [
@@ -151,10 +156,6 @@ component("gl") {
   }
   if (is_linux) {
     deps += [ "//third_party/libevent" ]
-    sources += [
-      "gl_image_linux_dma_buffer.cc",
-      "gl_image_linux_dma_buffer.h",
-    ]
   }
   if (use_x11) {
     sources += [
@@ -214,8 +215,8 @@ component("gl") {
       "gl_context_cgl.h",
       "gl_fence_apple.cc",
       "gl_fence_apple.h",
-      "gl_image_io_surface.cc",
       "gl_image_io_surface.h",
+      "gl_image_io_surface.mm",
       "scoped_cgl.cc",
       "scoped_cgl.h",
     ]
@@ -223,6 +224,7 @@ component("gl") {
     libs = [
       "IOSurface.framework",
       "OpenGL.framework",
+      "Quartz.framework",
     ]
   }
   if (is_android) {
@@ -250,6 +252,8 @@ component("gl") {
       "gl_context_ozone.cc",
       "gl_egl_api_implementation.cc",
       "gl_egl_api_implementation.h",
+      "gl_image_ozone_native_pixmap.cc",
+      "gl_image_ozone_native_pixmap.h",
       "gl_implementation_ozone.cc",
       "gl_surface_ozone.cc",
     ]
@@ -280,6 +284,36 @@ source_set("gl_unittest_utils") {
   ]
 }
 
+source_set("test_support") {
+  sources = [
+    "test/gl_surface_test_support.cc",
+    "test/gl_surface_test_support.h",
+  ]
+
+  configs += [ "//third_party/khronos:khronos_headers" ]
+
+  deps = [
+    ":gl",
+  ]
+
+  if (use_x11) {
+    configs += [ "//build/config/linux:x11" ]
+    deps += [
+      "//ui/gfx/x",
+      "//ui/platform_window/x11",
+    ]
+  }
+}
+
+# TODO(GYP): Delete this after we've converted everything to GN.
+# The _run targets exist only for compatibility w/ GYP.
+group("gl_unittests_run") {
+  testonly = true
+  deps = [
+    ":gl_unittests",
+  ]
+}
+
 test("gl_unittests") {
   sources = [
     "gl_api_unittest.cc",
@@ -294,11 +328,16 @@ test("gl_unittests") {
     ]
   }
 
+  if (use_x11) {
+    sources += [ "glx_api_unittest.cc" ]
+  }
+
   include_dirs = [ "//third_party/khronos" ]
 
   deps = [
     ":gl",
     ":gl_unittest_utils",
+    ":test_support",
     "//base",
     "//base/test:test_support",
     "//testing/gmock",
@@ -313,13 +352,13 @@ if (is_android) {
   }
 
   generate_jni("gl_jni_headers") {
-    deps = [
-      ":surface_jni_headers",
-    ]
     sources = [
       "../android/java/src/org/chromium/ui/gl/SurfaceTextureListener.java",
       "../android/java/src/org/chromium/ui/gl/SurfaceTexturePlatformWrapper.java",
     ]
+    public_deps = [
+      ":surface_jni_headers",
+    ]
     jni_package = "ui/gl"
   }
 }
diff --git a/chromium/ui/gl/android/scoped_java_surface.h b/chromium/ui/gl/android/scoped_java_surface.h
index 54ed2a45190..641df64a506 100644
--- a/chromium/ui/gl/android/scoped_java_surface.h
+++ b/chromium/ui/gl/android/scoped_java_surface.h
@@ -42,10 +42,10 @@ class GL_EXPORT ScopedJavaSurface {
 
   ~ScopedJavaSurface();
 
-  // Check whether the surface is an empty one.
+  // Checks whether the surface is an empty one.
   bool IsEmpty() const;
 
-  // Check whether the surface is hardware protected so that no readback is
+  // Checks whether the surface is hardware protected so that no readback is
   // possible.
   bool is_protected() const { return is_protected_; }
 
diff --git a/chromium/ui/gl/angle_platform_impl.cc b/chromium/ui/gl/angle_platform_impl.cc
index f534e98e32d..1f1085b5a45 100644
--- a/chromium/ui/gl/angle_platform_impl.cc
+++ b/chromium/ui/gl/angle_platform_impl.cc
@@ -29,6 +29,18 @@ const unsigned char* ANGLEPlatformImpl::getTraceCategoryEnabledFlag(
   return TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_group);
 }
 
+void ANGLEPlatformImpl::logError(const char* errorMessage) {
+  LOG(ERROR) << errorMessage;
+}
+
+void ANGLEPlatformImpl::logWarning(const char* warningMessage) {
+  LOG(WARNING) << warningMessage;
+}
+
+void ANGLEPlatformImpl::logInfo(const char* infoMessage) {
+  LOG(INFO) << infoMessage;
+}
+
 angle::Platform::TraceEventHandle ANGLEPlatformImpl::addTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
@@ -44,7 +56,7 @@ angle::Platform::TraceEventHandle ANGLEPlatformImpl::addTraceEvent(
       base::TraceTicks() + base::TimeDelta::FromSecondsD(timestamp);
   base::trace_event::TraceEventHandle handle =
       TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-          phase, category_group_enabled, name, id,
+          phase, category_group_enabled, name, id, trace_event_internal::kNoId,
           base::PlatformThread::CurrentId(), timestamp_tt, num_args, arg_names,
           arg_types, arg_values, nullptr, flags);
   angle::Platform::TraceEventHandle result;
diff --git a/chromium/ui/gl/angle_platform_impl.h b/chromium/ui/gl/angle_platform_impl.h
index 0549e7f511c..61dd0fb1385 100644
--- a/chromium/ui/gl/angle_platform_impl.h
+++ b/chromium/ui/gl/angle_platform_impl.h
@@ -22,6 +22,9 @@ class ANGLEPlatformImpl : public angle::Platform {
   // angle::Platform:
   double currentTime() override;
   double monotonicallyIncreasingTime() override;
+  void logError(const char* errorMessage) override;
+  void logWarning(const char* warningMessage) override;
+  void logInfo(const char* infoMessage) override;
   const unsigned char* getTraceCategoryEnabledFlag(
       const char* category_group) override;
   TraceEventHandle addTraceEvent(char phase,
diff --git a/chromium/ui/gl/generate_bindings.py b/chromium/ui/gl/generate_bindings.py
index 2667b24eee0..3cb87b073e8 100755
--- a/chromium/ui/gl/generate_bindings.py
+++ b/chromium/ui/gl/generate_bindings.py
@@ -36,15 +36,24 @@ array instead of the names array. Each version has the following keys:
    extensions: Extra Extensions for which the function is bound. Only needed
                in some cases where the extension cannot be parsed from the
                headers.
-
+   is_optional: True if the GetProcAddress can return NULL for the
+                function.  This may happen for example when functions
+                are added to a new version of an extension, but the
+                extension string is not modified.
 By default, the function gets its name from the first name in its names or
 versions array. This can be overridden by supplying a 'known_as' key.
+
 """
 GL_FUNCTIONS = [
 { 'return_type': 'void',
   'names': ['glActiveTexture'],
   'arguments': 'GLenum texture', },
 { 'return_type': 'void',
+  'known_as': 'glApplyFramebufferAttachmentCMAAINTEL',
+  'versions': [{ 'name': 'glApplyFramebufferAttachmentCMAAINTEL',
+                 'extensions': ['GL_INTEL_framebuffer_CMAA'] }],
+  'arguments': 'void', },
+{ 'return_type': 'void',
   'names': ['glAttachShader'],
   'arguments': 'GLuint program, GLuint shader', },
 { 'return_type': 'void',
@@ -235,6 +244,12 @@ GL_FUNCTIONS = [
   'arguments':
       'GLenum target, GLint level, GLint xoffset, GLint yoffset, '
       'GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height', },
+{ 'return_type': 'void',
+  'names': ['glCoverFillPathNV'],
+  'arguments': 'GLuint path, GLenum coverMode' },
+{ 'return_type': 'void',
+  'names': ['glCoverStrokePathNV'],
+  'arguments': 'GLuint name, GLenum coverMode' },
 { 'return_type': 'GLuint',
   'names': ['glCreateProgram'],
   'arguments': 'void', },
@@ -260,6 +275,9 @@ GL_FUNCTIONS = [
   'names': ['glDeleteFramebuffersEXT', 'glDeleteFramebuffers'],
   'arguments': 'GLsizei n, const GLuint* framebuffers', },
 { 'return_type': 'void',
+  'names': ['glDeletePathsNV'],
+  'arguments': 'GLuint path, GLsizei range' },
+{ 'return_type': 'void',
   'names': ['glDeleteProgram'],
   'arguments': 'GLuint program', },
 { 'return_type': 'void',
@@ -438,6 +456,9 @@ GL_FUNCTIONS = [
 { 'return_type': 'void',
   'names': ['glGenFramebuffersEXT', 'glGenFramebuffers'],
   'arguments': 'GLsizei n, GLuint* framebuffers', },
+{ 'return_type': 'GLuint',
+  'names': ['glGenPathsNV'],
+  'arguments': 'GLsizei range' },
 { 'return_type': 'void',
   'versions': [{ 'name': 'glGenQueries' },
                { 'name': 'glGenQueriesARB', },
@@ -705,6 +726,9 @@ GL_FUNCTIONS = [
   'names': ['glIsFramebufferEXT', 'glIsFramebuffer'],
   'arguments': 'GLuint framebuffer', },
 { 'return_type': 'GLboolean',
+  'names': ['glIsPathNV'],
+  'arguments': 'GLuint path' },
+{ 'return_type': 'GLboolean',
   'names': ['glIsProgram'],
   'arguments': 'GLuint program', },
 { 'return_type': 'GLboolean',
@@ -771,6 +795,19 @@ GL_FUNCTIONS = [
                                 'GL_NV_path_rendering'] },],
   'arguments': 'GLenum matrixMode' },
 { 'return_type': 'void',
+  'names': ['glPathCommandsNV'],
+  'arguments': 'GLuint path, GLsizei numCommands, const GLubyte* commands, '
+  'GLsizei numCoords, GLenum coordType, const GLvoid* coords' },
+{ 'return_type': 'void',
+  'names': ['glPathParameterfNV'],
+  'arguments': 'GLuint path, GLenum pname, GLfloat value' },
+{ 'return_type': 'void',
+  'names': ['glPathParameteriNV'],
+  'arguments': 'GLuint path, GLenum pname, GLint value' },
+{ 'return_type': 'void',
+  'names': ['glPathStencilFuncNV'],
+  'arguments': 'GLenum func, GLint ref, GLuint mask' },
+{ 'return_type': 'void',
   'versions': [{ 'name': 'glPauseTransformFeedback' }],
   'arguments': 'void', },
 { 'return_type': 'void',
@@ -889,6 +926,9 @@ GL_FUNCTIONS = [
   });
 """, },
 { 'return_type': 'void',
+  'names': ['glStencilFillPathNV'],
+  'arguments': 'GLuint path, GLenum fillMode, GLuint mask' },
+{ 'return_type': 'void',
   'names': ['glStencilFunc'],
   'arguments': 'GLenum func, GLint ref, GLuint mask', },
 { 'return_type': 'void',
@@ -906,6 +946,17 @@ GL_FUNCTIONS = [
 { 'return_type': 'void',
   'names': ['glStencilOpSeparate'],
   'arguments': 'GLenum face, GLenum fail, GLenum zfail, GLenum zpass', },
+{ 'return_type': 'void',
+  'names': ['glStencilStrokePathNV'],
+  'arguments': 'GLuint path, GLint reference, GLuint mask' },
+{ 'return_type': 'void',
+  'names': ['glStencilThenCoverFillPathNV'],
+  'arguments': 'GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode',
+  'is_optional': True, },
+{ 'return_type': 'void',
+  'names': ['glStencilThenCoverStrokePathNV'],
+  'arguments': 'GLuint path, GLint reference, GLuint mask, GLenum coverMode',
+  'is_optional': True, },
 { 'return_type': 'GLboolean',
   'known_as': 'glTestFenceAPPLE',
   'versions': [{ 'name': 'glTestFenceAPPLE',
@@ -1905,7 +1956,8 @@ namespace gfx {
         file.write('  else if (%s) {\n  ' % (cond))
 
       WriteFuncBinding(file, known_as, version['name'])
-      file.write('DCHECK(fn.%sFn);\n' % known_as)
+      if not 'is_optional' in func or not func['is_optional']:
+        file.write('DCHECK(fn.%sFn);\n' % known_as)
       file.write('}\n')
       i += 1
       first_version = False
diff --git a/chromium/ui/gl/gl.gyp b/chromium/ui/gl/gl.gyp
index 6d4d1f9fc63..f0f026a1ffe 100644
--- a/chromium/ui/gl/gl.gyp
+++ b/chromium/ui/gl/gl.gyp
@@ -115,12 +115,16 @@
         'gpu_switching_observer.h',
         'gpu_timing.cc',
         'gpu_timing.h',
+        'scoped_api.cc',
+        'scoped_api.h',
         'scoped_binders.cc',
         'scoped_binders.h',
         'scoped_make_current.cc',
         'scoped_make_current.h',
         'sync_control_vsync_provider.cc',
         'sync_control_vsync_provider.h',
+        'trace_util.cc',
+        'trace_util.h',
       ],
       'conditions': [
         ['OS in ("win", "android", "linux")', {
@@ -150,12 +154,6 @@
             'gl_implementation_osmesa.h',
           ],
         }],
-        ['OS=="linux"', {
-          'sources': [
-            'gl_image_linux_dma_buffer.cc',
-            'gl_image_linux_dma_buffer.h',
-          ],
-        }],
         ['use_x11 == 1', {
           'sources': [
             'gl_bindings_autogen_glx.cc',
@@ -225,7 +223,7 @@
             'gl_context_cgl.h',
             'gl_fence_apple.cc',
             'gl_fence_apple.h',
-            'gl_image_io_surface.cc',
+            'gl_image_io_surface.mm',
             'gl_image_io_surface.h',
             'scoped_cgl.cc',
             'scoped_cgl.h',
@@ -234,6 +232,7 @@
             'libraries': [
               '$(SDKROOT)/System/Library/Frameworks/IOSurface.framework',
               '$(SDKROOT)/System/Library/Frameworks/OpenGL.framework',
+              '$(SDKROOT)/System/Library/Frameworks/Quartz.framework',
             ],
           },
         }],
@@ -263,6 +262,10 @@
           'sources/': [ ['exclude', '^android/'] ],
         }],
         ['use_ozone==1', {
+          'sources': [
+            'gl_image_ozone_native_pixmap.cc',
+            'gl_image_ozone_native_pixmap.h',
+          ],
           'dependencies': [
             '../ozone/ozone.gyp:ozone',
             '../ozone/ozone.gyp:ozone_base',
@@ -291,6 +294,30 @@
         'gpu_timing_fake.h',
       ],
     },
+    {
+      'target_name': 'gl_test_support',
+      'type': 'static_library',
+      'dependencies': [
+        '../../third_party/khronos/khronos.gyp:khronos_headers',
+        'gl',
+      ],
+      'include_dirs': [
+        '../..',
+      ],
+      'sources': [
+        'test/gl_surface_test_support.cc',
+        'test/gl_surface_test_support.h',
+      ],
+      'conditions': [
+        ['use_x11==1', {
+          'dependencies': [
+            '../../build/linux/system.gyp:x11',
+            '../gfx/x/gfx_x11.gyp:gfx_x11',
+            '../platform_window/x11/x11_window.gyp:x11_window',
+          ],
+        }],
+      ],
+    },
   ],
   'conditions': [
     ['OS=="android"' , {
diff --git a/chromium/ui/gl/gl.isolate b/chromium/ui/gl/gl.isolate
new file mode 100644
index 00000000000..1ca7ef5a86c
--- /dev/null
+++ b/chromium/ui/gl/gl.isolate
@@ -0,0 +1,21 @@
+# 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.
+
+# This isolate expresses the dependency on the default behavior of
+# Chromium's OpenGL binding layer. Many targets (in particular test
+# targets) that use graphics rely on this layer either implicitly or
+# explicitly, but not all of them need a direct dependency on ANGLE,
+# especially as ANGLE is being brought up on more platforms. This
+# isolate allows these targets to continue to use Chromium's default
+# graphics code path, while others can depend directly on ANGLE on
+# non-Windows platforms.
+{
+  # If includes were supported in conditions, we'd prefer to
+  # conditionally include angle.isolate here only on Windows, rather
+  # than introducing another isolate for ANGLE on multiple
+  # platforms. https://github.com/luci/luci-py/issues/230
+  'includes': [
+    '../../third_party/angle/angle.isolate',
+  ],
+}
diff --git a/chromium/ui/gl/gl_api_unittest.cc b/chromium/ui/gl/gl_api_unittest.cc
index d2c9d9db2cb..66c938021c6 100644
--- a/chromium/ui/gl/gl_api_unittest.cc
+++ b/chromium/ui/gl/gl_api_unittest.cc
@@ -19,7 +19,6 @@ class GLContextFake : public GLContext {
                   GpuPreference gpu_preference) override {
     return true;
   }
-  void Destroy() override {}
   bool MakeCurrent(GLSurface* surface) override { return true; }
   void ReleaseCurrent(GLSurface* surface) override {}
   bool IsCurrent(GLSurface* surface) override { return true; }
@@ -37,16 +36,11 @@ class GLApiTest : public testing::Test {
  public:
   void SetUp() override {
     fake_extension_string_ = "";
+    fake_version_string_ = "";
     num_fake_extension_strings_ = 0;
     fake_extension_strings_ = nullptr;
 
     g_current_gl_context_tls = new base::ThreadLocalPointer<GLApi>;
-    api_.reset(new RealGLApi());
-
-    g_driver_gl.ClearBindings();
-    g_driver_gl.fn.glGetStringFn = &FakeGetString;
-    g_driver_gl.fn.glGetStringiFn = &FakeGetStringi;
-    g_driver_gl.fn.glGetIntegervFn = &FakeGetIntegervFn;
 
     SetGLGetProcAddressProc(
         static_cast<GLGetProcAddressProc>(&FakeGLGetProcAddress));
@@ -62,6 +56,7 @@ class GLApiTest : public testing::Test {
 
     SetGLImplementation(kGLImplementationNone);
     fake_extension_string_ = "";
+    fake_version_string_ = "";
     num_fake_extension_strings_ = 0;
     fake_extension_strings_ = nullptr;
   }
@@ -70,6 +65,11 @@ class GLApiTest : public testing::Test {
     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;
+
     fake_context_ = new GLContextFake();
     if (command_line)
       api_->InitializeWithCommandLine(&g_driver_gl, command_line);
@@ -82,15 +82,19 @@ class GLApiTest : public testing::Test {
   void SetFakeExtensionString(const char* fake_string) {
     SetGLImplementation(kGLImplementationDesktopGL);
     fake_extension_string_ = fake_string;
+    fake_version_string_ = "2.1";
   }
 
   void SetFakeExtensionStrings(const char** fake_strings, uint32_t count) {
-    SetGLImplementation(kGLImplementationDesktopGLCoreProfile);
+    SetGLImplementation(kGLImplementationDesktopGL);
     num_fake_extension_strings_ = count;
     fake_extension_strings_ = fake_strings;
+    fake_version_string_ = "3.0";
   }
 
   static const GLubyte* GL_BINDING_CALL FakeGetString(GLenum name) {
+    if (name == GL_VERSION)
+      return reinterpret_cast<const GLubyte*>(fake_version_string_);
     return reinterpret_cast<const GLubyte*>(fake_extension_string_);
   }
 
@@ -122,6 +126,7 @@ class GLApiTest : public testing::Test {
 
  protected:
   static const char* fake_extension_string_;
+  static const char* fake_version_string_;
 
   static uint32_t num_fake_extension_strings_;
   static const char** fake_extension_strings_;
@@ -132,6 +137,7 @@ class GLApiTest : public testing::Test {
 };
 
 const char* GLApiTest::fake_extension_string_ = "";
+const char* GLApiTest::fake_version_string_ = "";
 
 uint32_t GLApiTest::num_fake_extension_strings_ = 0;
 const char** GLApiTest::fake_extension_strings_ = nullptr;
diff --git a/chromium/ui/gl/gl_bindings.h b/chromium/ui/gl/gl_bindings.h
index 878e7767440..09725985b28 100644
--- a/chromium/ui/gl/gl_bindings.h
+++ b/chromium/ui/gl/gl_bindings.h
@@ -126,7 +126,6 @@
 #define GL_LATENCY_QUERY_CHROMIUM                        0x6007
 
 /* GL_CHROMIUM_async_pixel_transfers */
-#define GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM         0x6005
 #define GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM           0x6006
 
 // GL_CHROMIUM_sync_query
@@ -139,6 +138,9 @@
 // GL_CHROMIUM_yuv_420_image
 #define GL_RGB_YUV_420_CHROMIUM                          0x78FA
 
+// GL_CHROMIUM_ycbcr_422_image
+#define GL_RGB_YCBCR_422_CHROMIUM                        0x78FB
+
 // GL_CHROMIUM_schedule_overlay_plane
 #define GL_OVERLAY_TRANSFORM_NONE_CHROMIUM               0x9245
 #define GL_OVERLAY_TRANSFORM_FLIP_HORIZONTAL_CHROMIUM    0x9246
@@ -224,12 +226,36 @@
 #endif
 
 #ifndef GL_CHROMIUM_path_rendering
+#define GL_CHROMIUM_path_rendering 1
 // These match the corresponding values in NV_path_rendering
 // extension, eg tokens with CHROMIUM replaced with NV.
 #define GL_PATH_MODELVIEW_MATRIX_CHROMIUM 0x0BA6
 #define GL_PATH_PROJECTION_MATRIX_CHROMIUM 0x0BA7
 #define GL_PATH_MODELVIEW_CHROMIUM 0x1700
 #define GL_PATH_PROJECTION_CHROMIUM 0x1701
+#define GL_FLAT_CHROMIUM 0x1D00
+#define GL_CLOSE_PATH_CHROMIUM 0x00
+#define GL_MOVE_TO_CHROMIUM 0x02
+#define GL_LINE_TO_CHROMIUM 0x04
+#define GL_QUADRATIC_CURVE_TO_CHROMIUM 0x0A
+#define GL_CUBIC_CURVE_TO_CHROMIUM 0x0C
+#define GL_CONIC_CURVE_TO_CHROMIUM 0x1A
+#define GL_PATH_STROKE_WIDTH_CHROMIUM 0x9075
+#define GL_PATH_END_CAPS_CHROMIUM 0x9076
+#define GL_PATH_JOIN_STYLE_CHROMIUM 0x9079
+#define GL_PATH_MITER_LIMIT_CHROMIUM 0x907a
+#define GL_PATH_STROKE_BOUND_CHROMIUM 0x9086
+#define GL_COUNT_UP_CHROMIUM 0x9088
+#define GL_COUNT_DOWN_CHROMIUM 0x9089
+#define GL_CONVEX_HULL_CHROMIUM 0x908B
+#define GL_BOUNDING_BOX_CHROMIUM 0x908D
+#define GL_SQUARE_CHROMIUM 0x90a3
+#define GL_ROUND_CHROMIUM 0x90a4
+#define GL_BEVEL_CHROMIUM 0x90a6
+#define GL_MITER_REVERT_CHROMIUM 0x90a7
+#define GL_PATH_STENCIL_FUNC_CHROMIUM 0x90B7
+#define GL_PATH_STENCIL_REF_CHROMIUM 0x90B8
+#define GL_PATH_STENCIL_VALUE_MASK_CHROMIUM 0x90B9
 #endif
 
 #ifndef GL_KHR_blend_equation_advanced
diff --git a/chromium/ui/gl/gl_bindings_api_autogen_gl.h b/chromium/ui/gl/gl_bindings_api_autogen_gl.h
index 81160fc250c..aabf919edf1 100644
--- a/chromium/ui/gl/gl_bindings_api_autogen_gl.h
+++ b/chromium/ui/gl/gl_bindings_api_autogen_gl.h
@@ -9,6 +9,7 @@
 // DO NOT EDIT!
 
 void glActiveTextureFn(GLenum texture) override;
+void glApplyFramebufferAttachmentCMAAINTELFn(void) override;
 void glAttachShaderFn(GLuint program, GLuint shader) override;
 void glBeginQueryFn(GLenum target, GLuint id) override;
 void glBeginTransformFeedbackFn(GLenum primitiveMode) override;
@@ -182,6 +183,8 @@ void glCopyTexSubImage3DFn(GLenum target,
                            GLint y,
                            GLsizei width,
                            GLsizei height) override;
+void glCoverFillPathNVFn(GLuint path, GLenum coverMode) override;
+void glCoverStrokePathNVFn(GLuint name, GLenum coverMode) override;
 GLuint glCreateProgramFn(void) override;
 GLuint glCreateShaderFn(GLenum type) override;
 void glCullFaceFn(GLenum mode) override;
@@ -189,6 +192,7 @@ void glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) override;
 void glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) override;
 void glDeleteFencesNVFn(GLsizei n, const GLuint* fences) override;
 void glDeleteFramebuffersEXTFn(GLsizei n, const GLuint* framebuffers) override;
+void glDeletePathsNVFn(GLuint path, GLsizei range) override;
 void glDeleteProgramFn(GLuint program) override;
 void glDeleteQueriesFn(GLsizei n, const GLuint* ids) override;
 void glDeleteRenderbuffersEXTFn(GLsizei n,
@@ -279,6 +283,7 @@ void glGenerateMipmapEXTFn(GLenum target) override;
 void glGenFencesAPPLEFn(GLsizei n, GLuint* fences) override;
 void glGenFencesNVFn(GLsizei n, GLuint* fences) override;
 void glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) override;
+GLuint glGenPathsNVFn(GLsizei range) override;
 void glGenQueriesFn(GLsizei n, GLuint* ids) override;
 void glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) override;
 void glGenSamplersFn(GLsizei n, GLuint* samplers) override;
@@ -446,6 +451,7 @@ GLboolean glIsEnabledFn(GLenum cap) override;
 GLboolean glIsFenceAPPLEFn(GLuint fence) override;
 GLboolean glIsFenceNVFn(GLuint fence) override;
 GLboolean glIsFramebufferEXTFn(GLuint framebuffer) override;
+GLboolean glIsPathNVFn(GLuint path) override;
 GLboolean glIsProgramFn(GLuint program) override;
 GLboolean glIsQueryFn(GLuint query) override;
 GLboolean glIsRenderbufferEXTFn(GLuint renderbuffer) override;
@@ -464,6 +470,15 @@ void* glMapBufferRangeFn(GLenum target,
                          GLbitfield access) override;
 void glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) override;
 void glMatrixLoadIdentityEXTFn(GLenum matrixMode) override;
+void glPathCommandsNVFn(GLuint path,
+                        GLsizei numCommands,
+                        const GLubyte* commands,
+                        GLsizei numCoords,
+                        GLenum coordType,
+                        const GLvoid* coords) override;
+void glPathParameterfNVFn(GLuint path, GLenum pname, GLfloat value) override;
+void glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) override;
+void glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) override;
 void glPauseTransformFeedbackFn(void) override;
 void glPixelStoreiFn(GLenum pname, GLint param) override;
 void glPointParameteriFn(GLenum pname, GLint param) override;
@@ -533,6 +548,7 @@ void glShaderSourceFn(GLuint shader,
                       GLsizei count,
                       const char* const* str,
                       const GLint* length) override;
+void glStencilFillPathNVFn(GLuint path, GLenum fillMode, GLuint mask) override;
 void glStencilFuncFn(GLenum func, GLint ref, GLuint mask) override;
 void glStencilFuncSeparateFn(GLenum face,
                              GLenum func,
@@ -545,6 +561,17 @@ void glStencilOpSeparateFn(GLenum face,
                            GLenum fail,
                            GLenum zfail,
                            GLenum zpass) override;
+void glStencilStrokePathNVFn(GLuint path,
+                             GLint reference,
+                             GLuint mask) override;
+void glStencilThenCoverFillPathNVFn(GLuint path,
+                                    GLenum fillMode,
+                                    GLuint mask,
+                                    GLenum coverMode) override;
+void glStencilThenCoverStrokePathNVFn(GLuint path,
+                                      GLint reference,
+                                      GLuint mask,
+                                      GLenum coverMode) override;
 GLboolean glTestFenceAPPLEFn(GLuint fence) override;
 GLboolean glTestFenceNVFn(GLuint fence) override;
 void glTexImage2DFn(GLenum target,
diff --git a/chromium/ui/gl/gl_bindings_autogen_egl.cc b/chromium/ui/gl/gl_bindings_autogen_egl.cc
index 981dc8fa7b7..f0f5443bb7c 100644
--- a/chromium/ui/gl/gl_bindings_autogen_egl.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_egl.cc
@@ -215,8 +215,9 @@ static EGLBoolean GL_BINDING_CALL Debug_eglBindAPI(EGLenum api) {
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+static EGLBoolean GL_BINDING_CALL Debug_eglBindTexImage(EGLDisplay dpy,
+                                                        EGLSurface surface,
+                                                        EGLint buffer) {
   GL_SERVICE_LOG("eglBindTexImage"
                  << "(" << dpy << ", " << surface << ", " << buffer << ")");
   EGLBoolean result =
@@ -367,8 +368,8 @@ Debug_eglCreateWindowSurface(EGLDisplay dpy,
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
+static EGLBoolean GL_BINDING_CALL Debug_eglDestroyContext(EGLDisplay dpy,
+                                                          EGLContext ctx) {
   GL_SERVICE_LOG("eglDestroyContext"
                  << "(" << dpy << ", " << ctx << ")");
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroyContextFn(dpy, ctx);
@@ -376,8 +377,8 @@ Debug_eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) {
+static EGLBoolean GL_BINDING_CALL Debug_eglDestroyImageKHR(EGLDisplay dpy,
+                                                           EGLImageKHR image) {
   GL_SERVICE_LOG("eglDestroyImageKHR"
                  << "(" << dpy << ", " << image << ")");
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroyImageKHRFn(dpy, image);
@@ -385,8 +386,8 @@ Debug_eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) {
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglDestroySurface(EGLDisplay dpy, EGLSurface surface) {
+static EGLBoolean GL_BINDING_CALL Debug_eglDestroySurface(EGLDisplay dpy,
+                                                          EGLSurface surface) {
   GL_SERVICE_LOG("eglDestroySurface"
                  << "(" << dpy << ", " << surface << ")");
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroySurfaceFn(dpy, surface);
@@ -394,8 +395,8 @@ Debug_eglDestroySurface(EGLDisplay dpy, EGLSurface surface) {
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) {
+static EGLBoolean GL_BINDING_CALL Debug_eglDestroySyncKHR(EGLDisplay dpy,
+                                                          EGLSyncKHR sync) {
   GL_SERVICE_LOG("eglDestroySyncKHR"
                  << "(" << dpy << ", " << sync << ")");
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroySyncKHRFn(dpy, sync);
@@ -528,8 +529,9 @@ Debug_eglGetSyncValuesCHROMIUM(EGLDisplay dpy,
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
+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) << ")");
@@ -588,8 +590,8 @@ static EGLBoolean GL_BINDING_CALL Debug_eglQueryContext(EGLDisplay dpy,
   return result;
 }
 
-static const char* GL_BINDING_CALL
-Debug_eglQueryString(EGLDisplay dpy, EGLint name) {
+static const char* GL_BINDING_CALL Debug_eglQueryString(EGLDisplay dpy,
+                                                        EGLint name) {
   GL_SERVICE_LOG("eglQueryString"
                  << "(" << dpy << ", " << name << ")");
   const char* result = g_driver_egl.debug_fn.eglQueryStringFn(dpy, name);
@@ -624,8 +626,9 @@ Debug_eglQuerySurfacePointerANGLE(EGLDisplay dpy,
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+static EGLBoolean GL_BINDING_CALL Debug_eglReleaseTexImage(EGLDisplay dpy,
+                                                           EGLSurface surface,
+                                                           EGLint buffer) {
   GL_SERVICE_LOG("eglReleaseTexImage"
                  << "(" << dpy << ", " << surface << ", " << buffer << ")");
   EGLBoolean result =
@@ -656,8 +659,8 @@ static EGLBoolean GL_BINDING_CALL Debug_eglSurfaceAttrib(EGLDisplay dpy,
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
+static EGLBoolean GL_BINDING_CALL Debug_eglSwapBuffers(EGLDisplay dpy,
+                                                       EGLSurface surface) {
   GL_SERVICE_LOG("eglSwapBuffers"
                  << "(" << dpy << ", " << surface << ")");
   EGLBoolean result = g_driver_egl.debug_fn.eglSwapBuffersFn(dpy, surface);
@@ -665,8 +668,8 @@ Debug_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
   return result;
 }
 
-static EGLBoolean GL_BINDING_CALL
-Debug_eglSwapInterval(EGLDisplay dpy, EGLint interval) {
+static EGLBoolean GL_BINDING_CALL Debug_eglSwapInterval(EGLDisplay dpy,
+                                                        EGLint interval) {
   GL_SERVICE_LOG("eglSwapInterval"
                  << "(" << dpy << ", " << interval << ")");
   EGLBoolean result = g_driver_egl.debug_fn.eglSwapIntervalFn(dpy, interval);
@@ -708,8 +711,9 @@ static EGLBoolean GL_BINDING_CALL Debug_eglWaitNative(EGLint engine) {
   return result;
 }
 
-static EGLint GL_BINDING_CALL
-Debug_eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
+static EGLint GL_BINDING_CALL Debug_eglWaitSyncKHR(EGLDisplay dpy,
+                                                   EGLSyncKHR sync,
+                                                   EGLint flags) {
   GL_SERVICE_LOG("eglWaitSyncKHR"
                  << "(" << dpy << ", " << sync << ", " << flags << ")");
   EGLint result = g_driver_egl.debug_fn.eglWaitSyncKHRFn(dpy, sync, flags);
diff --git a/chromium/ui/gl/gl_bindings_autogen_gl.cc b/chromium/ui/gl/gl_bindings_autogen_gl.cc
index 391fe6f8929..2917d993b96 100644
--- a/chromium/ui/gl/gl_bindings_autogen_gl.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_gl.cc
@@ -26,6 +26,7 @@ DriverGL g_driver_gl;
 void DriverGL::InitializeStaticBindings() {
   fn.glActiveTextureFn = reinterpret_cast<glActiveTextureProc>(
       GetGLProcAddress("glActiveTexture"));
+  fn.glApplyFramebufferAttachmentCMAAINTELFn = 0;
   fn.glAttachShaderFn =
       reinterpret_cast<glAttachShaderProc>(GetGLProcAddress("glAttachShader"));
   fn.glBeginQueryFn = 0;
@@ -94,6 +95,8 @@ void DriverGL::InitializeStaticBindings() {
   fn.glCopyTexSubImage2DFn = reinterpret_cast<glCopyTexSubImage2DProc>(
       GetGLProcAddress("glCopyTexSubImage2D"));
   fn.glCopyTexSubImage3DFn = 0;
+  fn.glCoverFillPathNVFn = 0;
+  fn.glCoverStrokePathNVFn = 0;
   fn.glCreateProgramFn = reinterpret_cast<glCreateProgramProc>(
       GetGLProcAddress("glCreateProgram"));
   fn.glCreateShaderFn =
@@ -105,6 +108,7 @@ void DriverGL::InitializeStaticBindings() {
   fn.glDeleteFencesAPPLEFn = 0;
   fn.glDeleteFencesNVFn = 0;
   fn.glDeleteFramebuffersEXTFn = 0;
+  fn.glDeletePathsNVFn = 0;
   fn.glDeleteProgramFn = reinterpret_cast<glDeleteProgramProc>(
       GetGLProcAddress("glDeleteProgram"));
   fn.glDeleteQueriesFn = 0;
@@ -168,6 +172,7 @@ void DriverGL::InitializeStaticBindings() {
   fn.glGenFencesAPPLEFn = 0;
   fn.glGenFencesNVFn = 0;
   fn.glGenFramebuffersEXTFn = 0;
+  fn.glGenPathsNVFn = 0;
   fn.glGenQueriesFn = 0;
   fn.glGenRenderbuffersEXTFn = 0;
   fn.glGenSamplersFn = 0;
@@ -265,6 +270,7 @@ void DriverGL::InitializeStaticBindings() {
   fn.glIsFenceAPPLEFn = 0;
   fn.glIsFenceNVFn = 0;
   fn.glIsFramebufferEXTFn = 0;
+  fn.glIsPathNVFn = 0;
   fn.glIsProgramFn =
       reinterpret_cast<glIsProgramProc>(GetGLProcAddress("glIsProgram"));
   fn.glIsQueryFn = 0;
@@ -285,6 +291,10 @@ void DriverGL::InitializeStaticBindings() {
   fn.glMapBufferRangeFn = 0;
   fn.glMatrixLoadfEXTFn = 0;
   fn.glMatrixLoadIdentityEXTFn = 0;
+  fn.glPathCommandsNVFn = 0;
+  fn.glPathParameterfNVFn = 0;
+  fn.glPathParameteriNVFn = 0;
+  fn.glPathStencilFuncNVFn = 0;
   fn.glPauseTransformFeedbackFn = 0;
   fn.glPixelStoreiFn =
       reinterpret_cast<glPixelStoreiProc>(GetGLProcAddress("glPixelStorei"));
@@ -319,6 +329,7 @@ void DriverGL::InitializeStaticBindings() {
   fn.glShaderBinaryFn = 0;
   fn.glShaderSourceFn =
       reinterpret_cast<glShaderSourceProc>(GetGLProcAddress("glShaderSource"));
+  fn.glStencilFillPathNVFn = 0;
   fn.glStencilFuncFn =
       reinterpret_cast<glStencilFuncProc>(GetGLProcAddress("glStencilFunc"));
   fn.glStencilFuncSeparateFn = reinterpret_cast<glStencilFuncSeparateProc>(
@@ -331,6 +342,9 @@ void DriverGL::InitializeStaticBindings() {
       reinterpret_cast<glStencilOpProc>(GetGLProcAddress("glStencilOp"));
   fn.glStencilOpSeparateFn = reinterpret_cast<glStencilOpSeparateProc>(
       GetGLProcAddress("glStencilOpSeparate"));
+  fn.glStencilStrokePathNVFn = 0;
+  fn.glStencilThenCoverFillPathNVFn = 0;
+  fn.glStencilThenCoverStrokePathNVFn = 0;
   fn.glTestFenceAPPLEFn = 0;
   fn.glTestFenceNVFn = 0;
   fn.glTexImage2DFn =
@@ -515,6 +529,8 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
   ext.b_GL_IMG_multisampled_render_to_texture =
       extensions.find("GL_IMG_multisampled_render_to_texture ") !=
       std::string::npos;
+  ext.b_GL_INTEL_framebuffer_CMAA =
+      extensions.find("GL_INTEL_framebuffer_CMAA ") != std::string::npos;
   ext.b_GL_KHR_blend_equation_advanced =
       extensions.find("GL_KHR_blend_equation_advanced ") != std::string::npos;
   ext.b_GL_KHR_robustness =
@@ -533,6 +549,14 @@ 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"));
+    DCHECK(fn.glApplyFramebufferAttachmentCMAAINTELFn);
+  }
+
   debug_fn.glBeginQueryFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glBeginQueryFn =
@@ -764,6 +788,20 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glCopyTexSubImage3DFn);
   }
 
+  debug_fn.glCoverFillPathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverFillPathNVFn = reinterpret_cast<glCoverFillPathNVProc>(
+        GetGLProcAddress("glCoverFillPathNV"));
+    DCHECK(fn.glCoverFillPathNVFn);
+  }
+
+  debug_fn.glCoverStrokePathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverStrokePathNVFn = reinterpret_cast<glCoverStrokePathNVProc>(
+        GetGLProcAddress("glCoverStrokePathNV"));
+    DCHECK(fn.glCoverStrokePathNVFn);
+  }
+
   debug_fn.glDeleteFencesAPPLEFn = 0;
   if (ext.b_GL_APPLE_fence) {
     fn.glDeleteFencesAPPLEFn = reinterpret_cast<glDeleteFencesAPPLEProc>(
@@ -791,6 +829,13 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glDeleteFramebuffersEXTFn);
   }
 
+  debug_fn.glDeletePathsNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glDeletePathsNVFn = reinterpret_cast<glDeletePathsNVProc>(
+        GetGLProcAddress("glDeletePathsNV"));
+    DCHECK(fn.glDeletePathsNVFn);
+  }
+
   debug_fn.glDeleteQueriesFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
@@ -1097,6 +1142,13 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glGenFramebuffersEXTFn);
   }
 
+  debug_fn.glGenPathsNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glGenPathsNVFn =
+        reinterpret_cast<glGenPathsNVProc>(GetGLProcAddress("glGenPathsNV"));
+    DCHECK(fn.glGenPathsNVFn);
+  }
+
   debug_fn.glGenQueriesFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glGenQueriesFn =
@@ -1491,6 +1543,13 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glIsFramebufferEXTFn);
   }
 
+  debug_fn.glIsPathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glIsPathNVFn =
+        reinterpret_cast<glIsPathNVProc>(GetGLProcAddress("glIsPathNV"));
+    DCHECK(fn.glIsPathNVFn);
+  }
+
   debug_fn.glIsQueryFn = 0;
   if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
     fn.glIsQueryFn =
@@ -1594,6 +1653,34 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glMatrixLoadIdentityEXTFn);
   }
 
+  debug_fn.glPathCommandsNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathCommandsNVFn = reinterpret_cast<glPathCommandsNVProc>(
+        GetGLProcAddress("glPathCommandsNV"));
+    DCHECK(fn.glPathCommandsNVFn);
+  }
+
+  debug_fn.glPathParameterfNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathParameterfNVFn = reinterpret_cast<glPathParameterfNVProc>(
+        GetGLProcAddress("glPathParameterfNV"));
+    DCHECK(fn.glPathParameterfNVFn);
+  }
+
+  debug_fn.glPathParameteriNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathParameteriNVFn = reinterpret_cast<glPathParameteriNVProc>(
+        GetGLProcAddress("glPathParameteriNV"));
+    DCHECK(fn.glPathParameteriNVFn);
+  }
+
+  debug_fn.glPathStencilFuncNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathStencilFuncNVFn = reinterpret_cast<glPathStencilFuncNVProc>(
+        GetGLProcAddress("glPathStencilFuncNV"));
+    DCHECK(fn.glPathStencilFuncNVFn);
+  }
+
   debug_fn.glPauseTransformFeedbackFn = 0;
   if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u)) {
     fn.glPauseTransformFeedbackFn =
@@ -1772,6 +1859,34 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
     DCHECK(fn.glShaderBinaryFn);
   }
 
+  debug_fn.glStencilFillPathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilFillPathNVFn = reinterpret_cast<glStencilFillPathNVProc>(
+        GetGLProcAddress("glStencilFillPathNV"));
+    DCHECK(fn.glStencilFillPathNVFn);
+  }
+
+  debug_fn.glStencilStrokePathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilStrokePathNVFn = reinterpret_cast<glStencilStrokePathNVProc>(
+        GetGLProcAddress("glStencilStrokePathNV"));
+    DCHECK(fn.glStencilStrokePathNVFn);
+  }
+
+  debug_fn.glStencilThenCoverFillPathNVFn = 0;
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverFillPathNVFn =
+        reinterpret_cast<glStencilThenCoverFillPathNVProc>(
+            GetGLProcAddress("glStencilThenCoverFillPathNV"));
+  }
+
+  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>(
@@ -2016,8 +2131,15 @@ static void GL_BINDING_CALL Debug_glActiveTexture(GLenum texture) {
   g_driver_gl.debug_fn.glActiveTextureFn(texture);
 }
 
-static void GL_BINDING_CALL
-Debug_glAttachShader(GLuint program, GLuint shader) {
+static void GL_BINDING_CALL Debug_glApplyFramebufferAttachmentCMAAINTEL(void) {
+  GL_SERVICE_LOG("glApplyFramebufferAttachmentCMAAINTEL"
+                 << "("
+                 << ")");
+  g_driver_gl.debug_fn.glApplyFramebufferAttachmentCMAAINTELFn();
+}
+
+static void GL_BINDING_CALL Debug_glAttachShader(GLuint program,
+                                                 GLuint shader) {
   GL_SERVICE_LOG("glAttachShader"
                  << "(" << program << ", " << shader << ")");
   g_driver_gl.debug_fn.glAttachShaderFn(program, shader);
@@ -2036,8 +2158,9 @@ Debug_glBeginTransformFeedback(GLenum primitiveMode) {
   g_driver_gl.debug_fn.glBeginTransformFeedbackFn(primitiveMode);
 }
 
-static void GL_BINDING_CALL
-Debug_glBindAttribLocation(GLuint program, GLuint index, const char* name) {
+static void GL_BINDING_CALL Debug_glBindAttribLocation(GLuint program,
+                                                       GLuint index,
+                                                       const char* name) {
   GL_SERVICE_LOG("glBindAttribLocation"
                  << "(" << program << ", " << index << ", " << name << ")");
   g_driver_gl.debug_fn.glBindAttribLocationFn(program, index, name);
@@ -2050,8 +2173,9 @@ static void GL_BINDING_CALL Debug_glBindBuffer(GLenum target, GLuint buffer) {
   g_driver_gl.debug_fn.glBindBufferFn(target, buffer);
 }
 
-static void GL_BINDING_CALL
-Debug_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) {
+static void GL_BINDING_CALL Debug_glBindBufferBase(GLenum target,
+                                                   GLuint index,
+                                                   GLuint buffer) {
   GL_SERVICE_LOG("glBindBufferBase"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << index
                  << ", " << buffer << ")");
@@ -2090,16 +2214,16 @@ Debug_glBindFragDataLocationIndexed(GLuint program,
                                                        index, name);
 }
 
-static void GL_BINDING_CALL
-Debug_glBindFramebufferEXT(GLenum target, GLuint framebuffer) {
+static void GL_BINDING_CALL Debug_glBindFramebufferEXT(GLenum target,
+                                                       GLuint framebuffer) {
   GL_SERVICE_LOG("glBindFramebufferEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << framebuffer
                  << ")");
   g_driver_gl.debug_fn.glBindFramebufferEXTFn(target, framebuffer);
 }
 
-static void GL_BINDING_CALL
-Debug_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) {
+static void GL_BINDING_CALL Debug_glBindRenderbufferEXT(GLenum target,
+                                                        GLuint renderbuffer) {
   GL_SERVICE_LOG("glBindRenderbufferEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << renderbuffer << ")");
@@ -2119,8 +2243,8 @@ static void GL_BINDING_CALL Debug_glBindTexture(GLenum target, GLuint texture) {
   g_driver_gl.debug_fn.glBindTextureFn(target, texture);
 }
 
-static void GL_BINDING_CALL
-Debug_glBindTransformFeedback(GLenum target, GLuint id) {
+static void GL_BINDING_CALL Debug_glBindTransformFeedback(GLenum target,
+                                                          GLuint id) {
   GL_SERVICE_LOG("glBindTransformFeedback"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
   g_driver_gl.debug_fn.glBindTransformFeedbackFn(target, id);
@@ -2155,8 +2279,8 @@ static void GL_BINDING_CALL Debug_glBlendEquation(GLenum mode) {
   g_driver_gl.debug_fn.glBlendEquationFn(mode);
 }
 
-static void GL_BINDING_CALL
-Debug_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
+static void GL_BINDING_CALL Debug_glBlendEquationSeparate(GLenum modeRGB,
+                                                          GLenum modeAlpha) {
   GL_SERVICE_LOG("glBlendEquationSeparate"
                  << "(" << GLEnums::GetStringEnum(modeRGB) << ", "
                  << GLEnums::GetStringEnum(modeAlpha) << ")");
@@ -2288,24 +2412,27 @@ static void GL_BINDING_CALL Debug_glClearBufferfi(GLenum buffer,
   g_driver_gl.debug_fn.glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
 }
 
-static void GL_BINDING_CALL
-Debug_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) {
+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) << ")");
   g_driver_gl.debug_fn.glClearBufferfvFn(buffer, drawbuffer, value);
 }
 
-static void GL_BINDING_CALL
-Debug_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* 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) << ")");
   g_driver_gl.debug_fn.glClearBufferivFn(buffer, drawbuffer, value);
 }
 
-static void GL_BINDING_CALL
-Debug_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* 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) << ")");
@@ -2340,8 +2467,9 @@ static void GL_BINDING_CALL Debug_glClearStencil(GLint s) {
   g_driver_gl.debug_fn.glClearStencilFn(s);
 }
 
-static GLenum GL_BINDING_CALL
-Debug_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+static GLenum GL_BINDING_CALL Debug_glClientWaitSync(GLsync sync,
+                                                     GLbitfield flags,
+                                                     GLuint64 timeout) {
   GL_SERVICE_LOG("glClientWaitSync"
                  << "(" << sync << ", " << flags << ", " << timeout << ")");
   GLenum result = g_driver_gl.debug_fn.glClientWaitSyncFn(sync, flags, timeout);
@@ -2508,6 +2636,22 @@ static void GL_BINDING_CALL Debug_glCopyTexSubImage3D(GLenum target,
                                              zoffset, x, y, width, height);
 }
 
+static void GL_BINDING_CALL Debug_glCoverFillPathNV(GLuint path,
+                                                    GLenum coverMode) {
+  GL_SERVICE_LOG("glCoverFillPathNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(coverMode)
+                 << ")");
+  g_driver_gl.debug_fn.glCoverFillPathNVFn(path, coverMode);
+}
+
+static void GL_BINDING_CALL Debug_glCoverStrokePathNV(GLuint name,
+                                                      GLenum coverMode) {
+  GL_SERVICE_LOG("glCoverStrokePathNV"
+                 << "(" << name << ", " << GLEnums::GetStringEnum(coverMode)
+                 << ")");
+  g_driver_gl.debug_fn.glCoverStrokePathNVFn(name, coverMode);
+}
+
 static GLuint GL_BINDING_CALL Debug_glCreateProgram(void) {
   GL_SERVICE_LOG("glCreateProgram"
                  << "("
@@ -2531,24 +2675,24 @@ static void GL_BINDING_CALL Debug_glCullFace(GLenum mode) {
   g_driver_gl.debug_fn.glCullFaceFn(mode);
 }
 
-static void GL_BINDING_CALL
-Debug_glDeleteBuffersARB(GLsizei n, const GLuint* buffers) {
+static void GL_BINDING_CALL Debug_glDeleteBuffersARB(GLsizei n,
+                                                     const GLuint* buffers) {
   GL_SERVICE_LOG("glDeleteBuffersARB"
                  << "(" << n << ", " << static_cast<const void*>(buffers)
                  << ")");
   g_driver_gl.debug_fn.glDeleteBuffersARBFn(n, buffers);
 }
 
-static void GL_BINDING_CALL
-Debug_glDeleteFencesAPPLE(GLsizei n, const GLuint* fences) {
+static void GL_BINDING_CALL Debug_glDeleteFencesAPPLE(GLsizei n,
+                                                      const GLuint* fences) {
   GL_SERVICE_LOG("glDeleteFencesAPPLE"
                  << "(" << n << ", " << static_cast<const void*>(fences)
                  << ")");
   g_driver_gl.debug_fn.glDeleteFencesAPPLEFn(n, fences);
 }
 
-static void GL_BINDING_CALL
-Debug_glDeleteFencesNV(GLsizei n, const GLuint* fences) {
+static void GL_BINDING_CALL Debug_glDeleteFencesNV(GLsizei n,
+                                                   const GLuint* fences) {
   GL_SERVICE_LOG("glDeleteFencesNV"
                  << "(" << n << ", " << static_cast<const void*>(fences)
                  << ")");
@@ -2563,14 +2707,20 @@ Debug_glDeleteFramebuffersEXT(GLsizei n, const GLuint* framebuffers) {
   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 << ")");
+  g_driver_gl.debug_fn.glDeletePathsNVFn(path, range);
+}
+
 static void GL_BINDING_CALL Debug_glDeleteProgram(GLuint program) {
   GL_SERVICE_LOG("glDeleteProgram"
                  << "(" << program << ")");
   g_driver_gl.debug_fn.glDeleteProgramFn(program);
 }
 
-static void GL_BINDING_CALL
-Debug_glDeleteQueries(GLsizei n, const GLuint* ids) {
+static void GL_BINDING_CALL Debug_glDeleteQueries(GLsizei n,
+                                                  const GLuint* ids) {
   GL_SERVICE_LOG("glDeleteQueries"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
   g_driver_gl.debug_fn.glDeleteQueriesFn(n, ids);
@@ -2584,8 +2734,8 @@ Debug_glDeleteRenderbuffersEXT(GLsizei n, const GLuint* renderbuffers) {
   g_driver_gl.debug_fn.glDeleteRenderbuffersEXTFn(n, renderbuffers);
 }
 
-static void GL_BINDING_CALL
-Debug_glDeleteSamplers(GLsizei n, const GLuint* samplers) {
+static void GL_BINDING_CALL Debug_glDeleteSamplers(GLsizei n,
+                                                   const GLuint* samplers) {
   GL_SERVICE_LOG("glDeleteSamplers"
                  << "(" << n << ", " << static_cast<const void*>(samplers)
                  << ")");
@@ -2604,8 +2754,8 @@ static void GL_BINDING_CALL Debug_glDeleteSync(GLsync sync) {
   g_driver_gl.debug_fn.glDeleteSyncFn(sync);
 }
 
-static void GL_BINDING_CALL
-Debug_glDeleteTextures(GLsizei n, const GLuint* textures) {
+static void GL_BINDING_CALL Debug_glDeleteTextures(GLsizei n,
+                                                   const GLuint* textures) {
   GL_SERVICE_LOG("glDeleteTextures"
                  << "(" << n << ", " << static_cast<const void*>(textures)
                  << ")");
@@ -2651,8 +2801,8 @@ static void GL_BINDING_CALL Debug_glDepthRangef(GLclampf zNear, GLclampf zFar) {
   g_driver_gl.debug_fn.glDepthRangefFn(zNear, zFar);
 }
 
-static void GL_BINDING_CALL
-Debug_glDetachShader(GLuint program, GLuint shader) {
+static void GL_BINDING_CALL Debug_glDetachShader(GLuint program,
+                                                 GLuint shader) {
   GL_SERVICE_LOG("glDetachShader"
                  << "(" << program << ", " << shader << ")");
   g_driver_gl.debug_fn.glDetachShaderFn(program, shader);
@@ -2682,8 +2832,9 @@ Debug_glDiscardFramebufferEXT(GLenum target,
                                                  attachments);
 }
 
-static void GL_BINDING_CALL
-Debug_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
+static void GL_BINDING_CALL Debug_glDrawArrays(GLenum mode,
+                                               GLint first,
+                                               GLsizei count) {
   GL_SERVICE_LOG("glDrawArrays"
                  << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", "
                  << count << ")");
@@ -2708,8 +2859,8 @@ static void GL_BINDING_CALL Debug_glDrawBuffer(GLenum mode) {
   g_driver_gl.debug_fn.glDrawBufferFn(mode);
 }
 
-static void GL_BINDING_CALL
-Debug_glDrawBuffersARB(GLsizei n, const GLenum* bufs) {
+static void GL_BINDING_CALL Debug_glDrawBuffersARB(GLsizei n,
+                                                   const GLenum* bufs) {
   GL_SERVICE_LOG("glDrawBuffersARB"
                  << "(" << n << ", " << static_cast<const void*>(bufs) << ")");
   g_driver_gl.debug_fn.glDrawBuffersARBFn(n, bufs);
@@ -2797,8 +2948,8 @@ static void GL_BINDING_CALL Debug_glEndTransformFeedback(void) {
   g_driver_gl.debug_fn.glEndTransformFeedbackFn();
 }
 
-static GLsync GL_BINDING_CALL
-Debug_glFenceSync(GLenum condition, GLbitfield flags) {
+static GLsync GL_BINDING_CALL Debug_glFenceSync(GLenum condition,
+                                                GLbitfield flags) {
   GL_SERVICE_LOG("glFenceSync"
                  << "(" << GLEnums::GetStringEnum(condition) << ", " << flags
                  << ")");
@@ -2948,22 +3099,30 @@ static void GL_BINDING_CALL Debug_glGenFencesNV(GLsizei n, GLuint* fences) {
   g_driver_gl.debug_fn.glGenFencesNVFn(n, fences);
 }
 
-static void GL_BINDING_CALL
-Debug_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) {
+static void GL_BINDING_CALL Debug_glGenFramebuffersEXT(GLsizei n,
+                                                       GLuint* framebuffers) {
   GL_SERVICE_LOG("glGenFramebuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(framebuffers)
                  << ")");
   g_driver_gl.debug_fn.glGenFramebuffersEXTFn(n, framebuffers);
 }
 
+static GLuint GL_BINDING_CALL Debug_glGenPathsNV(GLsizei range) {
+  GL_SERVICE_LOG("glGenPathsNV"
+                 << "(" << range << ")");
+  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) << ")");
   g_driver_gl.debug_fn.glGenQueriesFn(n, ids);
 }
 
-static void GL_BINDING_CALL
-Debug_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers) {
+static void GL_BINDING_CALL Debug_glGenRenderbuffersEXT(GLsizei n,
+                                                        GLuint* renderbuffers) {
   GL_SERVICE_LOG("glGenRenderbuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(renderbuffers)
                  << ")");
@@ -2984,15 +3143,15 @@ static void GL_BINDING_CALL Debug_glGenTextures(GLsizei n, GLuint* textures) {
   g_driver_gl.debug_fn.glGenTexturesFn(n, textures);
 }
 
-static void GL_BINDING_CALL
-Debug_glGenTransformFeedbacks(GLsizei n, GLuint* ids) {
+static void GL_BINDING_CALL Debug_glGenTransformFeedbacks(GLsizei n,
+                                                          GLuint* ids) {
   GL_SERVICE_LOG("glGenTransformFeedbacks"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
   g_driver_gl.debug_fn.glGenTransformFeedbacksFn(n, ids);
 }
 
-static void GL_BINDING_CALL
-Debug_glGenVertexArraysOES(GLsizei n, GLuint* arrays) {
+static void GL_BINDING_CALL Debug_glGenVertexArraysOES(GLsizei n,
+                                                       GLuint* arrays) {
   GL_SERVICE_LOG("glGenVertexArraysOES"
                  << "(" << n << ", " << static_cast<const void*>(arrays)
                  << ")");
@@ -3087,8 +3246,8 @@ static void GL_BINDING_CALL Debug_glGetAttachedShaders(GLuint program,
                                               shaders);
 }
 
-static GLint GL_BINDING_CALL
-Debug_glGetAttribLocation(GLuint program, const char* name) {
+static GLint GL_BINDING_CALL Debug_glGetAttribLocation(GLuint program,
+                                                       const char* name) {
   GL_SERVICE_LOG("glGetAttribLocation"
                  << "(" << program << ", " << name << ")");
   GLint result = g_driver_gl.debug_fn.glGetAttribLocationFn(program, name);
@@ -3096,16 +3255,17 @@ Debug_glGetAttribLocation(GLuint program, const char* name) {
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glGetBooleanv(GLenum pname, GLboolean* params) {
+static void GL_BINDING_CALL Debug_glGetBooleanv(GLenum pname,
+                                                GLboolean* params) {
   GL_SERVICE_LOG("glGetBooleanv"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
   g_driver_gl.debug_fn.glGetBooleanvFn(pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
+static void GL_BINDING_CALL Debug_glGetBufferParameteriv(GLenum target,
+                                                         GLenum pname,
+                                                         GLint* params) {
   GL_SERVICE_LOG("glGetBufferParameteriv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
@@ -3124,8 +3284,9 @@ static GLenum GL_BINDING_CALL Debug_glGetError(void) {
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glGetFenceivNV(GLuint fence, GLenum pname, GLint* params) {
+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) << ")");
@@ -3139,8 +3300,8 @@ static void GL_BINDING_CALL Debug_glGetFloatv(GLenum pname, GLfloat* params) {
   g_driver_gl.debug_fn.glGetFloatvFn(pname, params);
 }
 
-static GLint GL_BINDING_CALL
-Debug_glGetFragDataLocation(GLuint program, const char* name) {
+static GLint GL_BINDING_CALL Debug_glGetFragDataLocation(GLuint program,
+                                                         const char* name) {
   GL_SERVICE_LOG("glGetFragDataLocation"
                  << "(" << program << ", " << name << ")");
   GLint result = g_driver_gl.debug_fn.glGetFragDataLocationFn(program, name);
@@ -3171,24 +3332,26 @@ static GLenum GL_BINDING_CALL Debug_glGetGraphicsResetStatusARB(void) {
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glGetInteger64i_v(GLenum target, GLuint index, GLint64* data) {
+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) << ")");
   g_driver_gl.debug_fn.glGetInteger64i_vFn(target, index, data);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetInteger64v(GLenum pname, GLint64* params) {
+static void GL_BINDING_CALL Debug_glGetInteger64v(GLenum pname,
+                                                  GLint64* params) {
   GL_SERVICE_LOG("glGetInteger64v"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
   g_driver_gl.debug_fn.glGetInteger64vFn(pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetIntegeri_v(GLenum target, GLuint index, GLint* 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) << ")");
@@ -3241,8 +3404,9 @@ static void GL_BINDING_CALL Debug_glGetProgramInfoLog(GLuint program,
   g_driver_gl.debug_fn.glGetProgramInfoLogFn(program, bufsize, length, infolog);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetProgramiv(GLuint program, GLenum pname, GLint* 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) << ")");
@@ -3263,8 +3427,9 @@ Debug_glGetProgramResourceLocation(GLuint program,
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glGetQueryiv(GLenum target, GLenum pname, GLint* params) {
+static void GL_BINDING_CALL Debug_glGetQueryiv(GLenum target,
+                                               GLenum pname,
+                                               GLint* params) {
   GL_SERVICE_LOG("glGetQueryiv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
@@ -3272,32 +3437,36 @@ Debug_glGetQueryiv(GLenum target, GLenum pname, GLint* params) {
   g_driver_gl.debug_fn.glGetQueryivFn(target, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* 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) << ")");
   g_driver_gl.debug_fn.glGetQueryObjecti64vFn(id, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetQueryObjectiv(GLuint id, GLenum pname, GLint* 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) << ")");
   g_driver_gl.debug_fn.glGetQueryObjectivFn(id, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* 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) << ")");
   g_driver_gl.debug_fn.glGetQueryObjectui64vFn(id, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* 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) << ")");
@@ -3315,16 +3484,18 @@ Debug_glGetRenderbufferParameterivEXT(GLenum target,
   g_driver_gl.debug_fn.glGetRenderbufferParameterivEXTFn(target, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* 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) << ")");
   g_driver_gl.debug_fn.glGetSamplerParameterfvFn(sampler, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* 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) << ")");
@@ -3342,8 +3513,9 @@ static void GL_BINDING_CALL Debug_glGetShaderInfoLog(GLuint shader,
   g_driver_gl.debug_fn.glGetShaderInfoLogFn(shader, bufsize, length, infolog);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetShaderiv(GLuint shader, GLenum pname, GLint* params) {
+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) << ")");
@@ -3383,8 +3555,8 @@ static const GLubyte* GL_BINDING_CALL Debug_glGetString(GLenum name) {
   return result;
 }
 
-static const GLubyte* GL_BINDING_CALL
-Debug_glGetStringi(GLenum name, GLuint index) {
+static const GLubyte* GL_BINDING_CALL Debug_glGetStringi(GLenum name,
+                                                         GLuint index) {
   GL_SERVICE_LOG("glGetStringi"
                  << "(" << GLEnums::GetStringEnum(name) << ", " << index
                  << ")");
@@ -3427,8 +3599,9 @@ static void GL_BINDING_CALL Debug_glGetTexLevelParameteriv(GLenum target,
   g_driver_gl.debug_fn.glGetTexLevelParameterivFn(target, level, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
+static void GL_BINDING_CALL Debug_glGetTexParameterfv(GLenum target,
+                                                      GLenum pname,
+                                                      GLfloat* params) {
   GL_SERVICE_LOG("glGetTexParameterfv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
@@ -3436,8 +3609,9 @@ Debug_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
   g_driver_gl.debug_fn.glGetTexParameterfvFn(target, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
+static void GL_BINDING_CALL Debug_glGetTexParameteriv(GLenum target,
+                                                      GLenum pname,
+                                                      GLint* params) {
   GL_SERVICE_LOG("glGetTexParameteriv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
@@ -3485,8 +3659,9 @@ Debug_glGetUniformBlockIndex(GLuint program, const char* uniformBlockName) {
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glGetUniformfv(GLuint program, GLint location, GLfloat* params) {
+static void GL_BINDING_CALL Debug_glGetUniformfv(GLuint program,
+                                                 GLint location,
+                                                 GLfloat* params) {
   GL_SERVICE_LOG("glGetUniformfv"
                  << "(" << program << ", " << location << ", "
                  << static_cast<const void*>(params) << ")");
@@ -3506,16 +3681,17 @@ Debug_glGetUniformIndices(GLuint program,
                                              uniformNames, uniformIndices);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetUniformiv(GLuint program, GLint location, GLint* params) {
+static void GL_BINDING_CALL Debug_glGetUniformiv(GLuint program,
+                                                 GLint location,
+                                                 GLint* params) {
   GL_SERVICE_LOG("glGetUniformiv"
                  << "(" << program << ", " << location << ", "
                  << static_cast<const void*>(params) << ")");
   g_driver_gl.debug_fn.glGetUniformivFn(program, location, params);
 }
 
-static GLint GL_BINDING_CALL
-Debug_glGetUniformLocation(GLuint program, const char* name) {
+static GLint GL_BINDING_CALL Debug_glGetUniformLocation(GLuint program,
+                                                        const char* name) {
   GL_SERVICE_LOG("glGetUniformLocation"
                  << "(" << program << ", " << name << ")");
   GLint result = g_driver_gl.debug_fn.glGetUniformLocationFn(program, name);
@@ -3523,32 +3699,36 @@ Debug_glGetUniformLocation(GLuint program, const char* name) {
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glGetUniformuiv(GLuint program, GLint location, GLuint* params) {
+static void GL_BINDING_CALL Debug_glGetUniformuiv(GLuint program,
+                                                  GLint location,
+                                                  GLuint* params) {
   GL_SERVICE_LOG("glGetUniformuiv"
                  << "(" << program << ", " << location << ", "
                  << static_cast<const void*>(params) << ")");
   g_driver_gl.debug_fn.glGetUniformuivFn(program, location, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* 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) << ")");
   g_driver_gl.debug_fn.glGetVertexAttribfvFn(index, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* 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) << ")");
   g_driver_gl.debug_fn.glGetVertexAttribivFn(index, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) {
+static void GL_BINDING_CALL Debug_glGetVertexAttribPointerv(GLuint index,
+                                                            GLenum pname,
+                                                            void** pointer) {
   GL_SERVICE_LOG("glGetVertexAttribPointerv"
                  << "(" << index << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << pointer << ")");
@@ -3562,8 +3742,8 @@ static void GL_BINDING_CALL Debug_glHint(GLenum target, GLenum mode) {
   g_driver_gl.debug_fn.glHintFn(target, mode);
 }
 
-static void GL_BINDING_CALL
-Debug_glInsertEventMarkerEXT(GLsizei length, const char* marker) {
+static void GL_BINDING_CALL Debug_glInsertEventMarkerEXT(GLsizei length,
+                                                         const char* marker) {
   GL_SERVICE_LOG("glInsertEventMarkerEXT"
                  << "(" << length << ", " << marker << ")");
   g_driver_gl.debug_fn.glInsertEventMarkerEXTFn(length, marker);
@@ -3638,6 +3818,14 @@ static GLboolean GL_BINDING_CALL Debug_glIsFramebufferEXT(GLuint framebuffer) {
   return result;
 }
 
+static GLboolean GL_BINDING_CALL Debug_glIsPathNV(GLuint path) {
+  GL_SERVICE_LOG("glIsPathNV"
+                 << "(" << path << ")");
+  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 << ")");
@@ -3745,8 +3933,8 @@ static void* GL_BINDING_CALL Debug_glMapBufferRange(GLenum target,
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glMatrixLoadfEXT(GLenum matrixMode, const GLfloat* m) {
+static void GL_BINDING_CALL Debug_glMatrixLoadfEXT(GLenum matrixMode,
+                                                   const GLfloat* m) {
   GL_SERVICE_LOG("glMatrixLoadfEXT"
                  << "(" << GLEnums::GetStringEnum(matrixMode) << ", "
                  << static_cast<const void*>(m) << ")");
@@ -3759,6 +3947,48 @@ static void GL_BINDING_CALL Debug_glMatrixLoadIdentityEXT(GLenum matrixMode) {
   g_driver_gl.debug_fn.glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
+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) << ")");
+  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 << ")");
+  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 << ")");
+  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 << ")");
+  g_driver_gl.debug_fn.glPathStencilFuncNVFn(func, ref, mask);
+}
+
 static void GL_BINDING_CALL Debug_glPauseTransformFeedback(void) {
   GL_SERVICE_LOG("glPauseTransformFeedback"
                  << "("
@@ -3780,8 +4010,8 @@ static void GL_BINDING_CALL Debug_glPointParameteri(GLenum pname, GLint param) {
   g_driver_gl.debug_fn.glPointParameteriFn(pname, param);
 }
 
-static void GL_BINDING_CALL
-Debug_glPolygonOffset(GLfloat factor, GLfloat units) {
+static void GL_BINDING_CALL Debug_glPolygonOffset(GLfloat factor,
+                                                  GLfloat units) {
   GL_SERVICE_LOG("glPolygonOffset"
                  << "(" << factor << ", " << units << ")");
   g_driver_gl.debug_fn.glPolygonOffsetFn(factor, units);
@@ -3805,16 +4035,17 @@ static void GL_BINDING_CALL Debug_glProgramBinary(GLuint program,
   g_driver_gl.debug_fn.glProgramBinaryFn(program, binaryFormat, binary, length);
 }
 
-static void GL_BINDING_CALL
-Debug_glProgramParameteri(GLuint program, GLenum pname, GLint value) {
+static void GL_BINDING_CALL Debug_glProgramParameteri(GLuint program,
+                                                      GLenum pname,
+                                                      GLint value) {
   GL_SERVICE_LOG("glProgramParameteri"
                  << "(" << program << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << value << ")");
   g_driver_gl.debug_fn.glProgramParameteriFn(program, pname, value);
 }
 
-static void GL_BINDING_CALL
-Debug_glPushGroupMarkerEXT(GLsizei length, const char* marker) {
+static void GL_BINDING_CALL Debug_glPushGroupMarkerEXT(GLsizei length,
+                                                       const char* marker) {
   GL_SERVICE_LOG("glPushGroupMarkerEXT"
                  << "(" << length << ", " << marker << ")");
   g_driver_gl.debug_fn.glPushGroupMarkerEXTFn(length, marker);
@@ -3931,16 +4162,17 @@ static void GL_BINDING_CALL Debug_glResumeTransformFeedback(void) {
   g_driver_gl.debug_fn.glResumeTransformFeedbackFn();
 }
 
-static void GL_BINDING_CALL
-Debug_glSampleCoverage(GLclampf value, GLboolean invert) {
+static void GL_BINDING_CALL Debug_glSampleCoverage(GLclampf value,
+                                                   GLboolean invert) {
   GL_SERVICE_LOG("glSampleCoverage"
                  << "(" << value << ", " << GLEnums::GetStringBool(invert)
                  << ")");
   g_driver_gl.debug_fn.glSampleCoverageFn(value, invert);
 }
 
-static void GL_BINDING_CALL
-Debug_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
+static void GL_BINDING_CALL Debug_glSamplerParameterf(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLfloat param) {
   GL_SERVICE_LOG("glSamplerParameterf"
                  << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << param << ")");
@@ -3956,24 +4188,28 @@ static void GL_BINDING_CALL Debug_glSamplerParameterfv(GLuint sampler,
   g_driver_gl.debug_fn.glSamplerParameterfvFn(sampler, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
+static void GL_BINDING_CALL Debug_glSamplerParameteri(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLint param) {
   GL_SERVICE_LOG("glSamplerParameteri"
                  << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << param << ")");
   g_driver_gl.debug_fn.glSamplerParameteriFn(sampler, pname, param);
 }
 
-static void GL_BINDING_CALL
-Debug_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* params) {
+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) << ")");
   g_driver_gl.debug_fn.glSamplerParameterivFn(sampler, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
+static void GL_BINDING_CALL Debug_glScissor(GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height) {
   GL_SERVICE_LOG("glScissor"
                  << "(" << x << ", " << y << ", " << width << ", " << height
                  << ")");
@@ -4032,16 +4268,28 @@ static void GL_BINDING_CALL Debug_glShaderSource(GLuint shader,
   });
 }
 
-static void GL_BINDING_CALL
-Debug_glStencilFunc(GLenum func, GLint ref, GLuint mask) {
+static void GL_BINDING_CALL Debug_glStencilFillPathNV(GLuint path,
+                                                      GLenum fillMode,
+                                                      GLuint mask) {
+  GL_SERVICE_LOG("glStencilFillPathNV"
+                 << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
+                 << ", " << mask << ")");
+  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 << ")");
   g_driver_gl.debug_fn.glStencilFuncFn(func, ref, mask);
 }
 
-static void GL_BINDING_CALL
-Debug_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint 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
@@ -4055,15 +4303,16 @@ static void GL_BINDING_CALL Debug_glStencilMask(GLuint mask) {
   g_driver_gl.debug_fn.glStencilMaskFn(mask);
 }
 
-static void GL_BINDING_CALL
-Debug_glStencilMaskSeparate(GLenum face, GLuint mask) {
+static void GL_BINDING_CALL Debug_glStencilMaskSeparate(GLenum face,
+                                                        GLuint mask) {
   GL_SERVICE_LOG("glStencilMaskSeparate"
                  << "(" << GLEnums::GetStringEnum(face) << ", " << mask << ")");
   g_driver_gl.debug_fn.glStencilMaskSeparateFn(face, mask);
 }
 
-static void GL_BINDING_CALL
-Debug_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
+static void GL_BINDING_CALL Debug_glStencilOp(GLenum fail,
+                                              GLenum zfail,
+                                              GLenum zpass) {
   GL_SERVICE_LOG("glStencilOp"
                  << "(" << GLEnums::GetStringEnum(fail) << ", "
                  << GLEnums::GetStringEnum(zfail) << ", "
@@ -4083,6 +4332,39 @@ static void GL_BINDING_CALL Debug_glStencilOpSeparate(GLenum face,
   g_driver_gl.debug_fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
+static void GL_BINDING_CALL Debug_glStencilStrokePathNV(GLuint path,
+                                                        GLint reference,
+                                                        GLuint mask) {
+  GL_SERVICE_LOG("glStencilStrokePathNV"
+                 << "(" << path << ", " << reference << ", " << mask << ")");
+  g_driver_gl.debug_fn.glStencilStrokePathNVFn(path, reference, mask);
+}
+
+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)
+                 << ")");
+  g_driver_gl.debug_fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask,
+                                                      coverMode);
+}
+
+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) << ")");
+  g_driver_gl.debug_fn.glStencilThenCoverStrokePathNVFn(path, reference, mask,
+                                                        coverMode);
+}
+
 static GLboolean GL_BINDING_CALL Debug_glTestFenceAPPLE(GLuint fence) {
   GL_SERVICE_LOG("glTestFenceAPPLE"
                  << "(" << fence << ")");
@@ -4140,16 +4422,18 @@ static void GL_BINDING_CALL Debug_glTexImage3D(GLenum target,
                                       pixels);
 }
 
-static void GL_BINDING_CALL
-Debug_glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
+static void GL_BINDING_CALL Debug_glTexParameterf(GLenum target,
+                                                  GLenum pname,
+                                                  GLfloat param) {
   GL_SERVICE_LOG("glTexParameterf"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", " << param << ")");
   g_driver_gl.debug_fn.glTexParameterfFn(target, pname, param);
 }
 
-static void GL_BINDING_CALL
-Debug_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) {
+static void GL_BINDING_CALL Debug_glTexParameterfv(GLenum target,
+                                                   GLenum pname,
+                                                   const GLfloat* params) {
   GL_SERVICE_LOG("glTexParameterfv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
@@ -4157,16 +4441,18 @@ Debug_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) {
   g_driver_gl.debug_fn.glTexParameterfvFn(target, pname, params);
 }
 
-static void GL_BINDING_CALL
-Debug_glTexParameteri(GLenum target, GLenum pname, GLint param) {
+static void GL_BINDING_CALL Debug_glTexParameteri(GLenum target,
+                                                  GLenum pname,
+                                                  GLint param) {
   GL_SERVICE_LOG("glTexParameteri"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", " << param << ")");
   g_driver_gl.debug_fn.glTexParameteriFn(target, pname, param);
 }
 
-static void GL_BINDING_CALL
-Debug_glTexParameteriv(GLenum target, GLenum pname, const GLint* 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) << ", "
@@ -4262,8 +4548,9 @@ static void GL_BINDING_CALL Debug_glUniform1f(GLint location, GLfloat x) {
   g_driver_gl.debug_fn.glUniform1fFn(location, x);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform1fv(GLint location, GLsizei count, const GLfloat* v) {
+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) << ")");
@@ -4276,8 +4563,9 @@ static void GL_BINDING_CALL Debug_glUniform1i(GLint location, GLint x) {
   g_driver_gl.debug_fn.glUniform1iFn(location, x);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform1iv(GLint location, GLsizei count, const GLint* v) {
+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) << ")");
@@ -4290,101 +4578,117 @@ static void GL_BINDING_CALL Debug_glUniform1ui(GLint location, GLuint v0) {
   g_driver_gl.debug_fn.glUniform1uiFn(location, v0);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform1uiv(GLint location, GLsizei count, const GLuint* v) {
+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) << ")");
   g_driver_gl.debug_fn.glUniform1uivFn(location, count, v);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform2f(GLint location, GLfloat x, GLfloat y) {
+static void GL_BINDING_CALL Debug_glUniform2f(GLint location,
+                                              GLfloat x,
+                                              GLfloat y) {
   GL_SERVICE_LOG("glUniform2f"
                  << "(" << location << ", " << x << ", " << y << ")");
   g_driver_gl.debug_fn.glUniform2fFn(location, x, y);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform2fv(GLint location, GLsizei count, const GLfloat* v) {
+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) << ")");
   g_driver_gl.debug_fn.glUniform2fvFn(location, count, v);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform2i(GLint location, GLint x, GLint y) {
+static void GL_BINDING_CALL Debug_glUniform2i(GLint location,
+                                              GLint x,
+                                              GLint y) {
   GL_SERVICE_LOG("glUniform2i"
                  << "(" << location << ", " << x << ", " << y << ")");
   g_driver_gl.debug_fn.glUniform2iFn(location, x, y);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform2iv(GLint location, GLsizei count, const GLint* v) {
+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) << ")");
   g_driver_gl.debug_fn.glUniform2ivFn(location, count, v);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform2ui(GLint location, GLuint v0, GLuint v1) {
+static void GL_BINDING_CALL Debug_glUniform2ui(GLint location,
+                                               GLuint v0,
+                                               GLuint v1) {
   GL_SERVICE_LOG("glUniform2ui"
                  << "(" << location << ", " << v0 << ", " << v1 << ")");
   g_driver_gl.debug_fn.glUniform2uiFn(location, v0, v1);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform2uiv(GLint location, GLsizei count, const GLuint* v) {
+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) << ")");
   g_driver_gl.debug_fn.glUniform2uivFn(location, count, v);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
+static void GL_BINDING_CALL Debug_glUniform3f(GLint location,
+                                              GLfloat x,
+                                              GLfloat y,
+                                              GLfloat z) {
   GL_SERVICE_LOG("glUniform3f"
                  << "(" << location << ", " << x << ", " << y << ", " << z
                  << ")");
   g_driver_gl.debug_fn.glUniform3fFn(location, x, y, z);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform3fv(GLint location, GLsizei count, const GLfloat* v) {
+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) << ")");
   g_driver_gl.debug_fn.glUniform3fvFn(location, count, v);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform3i(GLint location, GLint x, GLint y, GLint z) {
+static void GL_BINDING_CALL Debug_glUniform3i(GLint location,
+                                              GLint x,
+                                              GLint y,
+                                              GLint z) {
   GL_SERVICE_LOG("glUniform3i"
                  << "(" << location << ", " << x << ", " << y << ", " << z
                  << ")");
   g_driver_gl.debug_fn.glUniform3iFn(location, x, y, z);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform3iv(GLint location, GLsizei count, const GLint* v) {
+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) << ")");
   g_driver_gl.debug_fn.glUniform3ivFn(location, count, v);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) {
+static void GL_BINDING_CALL Debug_glUniform3ui(GLint location,
+                                               GLuint v0,
+                                               GLuint v1,
+                                               GLuint v2) {
   GL_SERVICE_LOG("glUniform3ui"
                  << "(" << location << ", " << v0 << ", " << v1 << ", " << v2
                  << ")");
   g_driver_gl.debug_fn.glUniform3uiFn(location, v0, v1, v2);
 }
 
-static void GL_BINDING_CALL
-Debug_glUniform3uiv(GLint location, GLsizei count, const GLuint* v) {
+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) << ")");
@@ -4399,8 +4703,9 @@ Debug_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
   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) {
+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) << ")");
@@ -4415,8 +4720,9 @@ Debug_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
   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) {
+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) << ")");
@@ -4431,8 +4737,9 @@ Debug_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
   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) {
+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) << ")");
@@ -4581,38 +4888,41 @@ static void GL_BINDING_CALL Debug_glVertexAttrib1f(GLuint indx, GLfloat x) {
   g_driver_gl.debug_fn.glVertexAttrib1fFn(indx, x);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttrib1fv(GLuint indx, const GLfloat* values) {
+static void GL_BINDING_CALL Debug_glVertexAttrib1fv(GLuint indx,
+                                                    const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib1fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
   g_driver_gl.debug_fn.glVertexAttrib1fvFn(indx, values);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
+static void GL_BINDING_CALL Debug_glVertexAttrib2f(GLuint indx,
+                                                   GLfloat x,
+                                                   GLfloat y) {
   GL_SERVICE_LOG("glVertexAttrib2f"
                  << "(" << indx << ", " << x << ", " << y << ")");
   g_driver_gl.debug_fn.glVertexAttrib2fFn(indx, x, y);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttrib2fv(GLuint indx, const GLfloat* values) {
+static void GL_BINDING_CALL Debug_glVertexAttrib2fv(GLuint indx,
+                                                    const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib2fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
   g_driver_gl.debug_fn.glVertexAttrib2fvFn(indx, values);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
+static void GL_BINDING_CALL Debug_glVertexAttrib3f(GLuint indx,
+                                                   GLfloat x,
+                                                   GLfloat y,
+                                                   GLfloat z) {
   GL_SERVICE_LOG("glVertexAttrib3f"
                  << "(" << indx << ", " << x << ", " << y << ", " << z << ")");
   g_driver_gl.debug_fn.glVertexAttrib3fFn(indx, x, y, z);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttrib3fv(GLuint indx, const GLfloat* values) {
+static void GL_BINDING_CALL Debug_glVertexAttrib3fv(GLuint indx,
+                                                    const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib3fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
@@ -4630,16 +4940,16 @@ static void GL_BINDING_CALL Debug_glVertexAttrib4f(GLuint indx,
   g_driver_gl.debug_fn.glVertexAttrib4fFn(indx, x, y, z, w);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttrib4fv(GLuint indx, const GLfloat* values) {
+static void GL_BINDING_CALL Debug_glVertexAttrib4fv(GLuint indx,
+                                                    const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib4fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
   g_driver_gl.debug_fn.glVertexAttrib4fvFn(indx, values);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
+static void GL_BINDING_CALL Debug_glVertexAttribDivisorANGLE(GLuint index,
+                                                             GLuint divisor) {
   GL_SERVICE_LOG("glVertexAttribDivisorANGLE"
                  << "(" << index << ", " << divisor << ")");
   g_driver_gl.debug_fn.glVertexAttribDivisorANGLEFn(index, divisor);
@@ -4653,8 +4963,8 @@ Debug_glVertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) {
   g_driver_gl.debug_fn.glVertexAttribI4iFn(indx, x, y, z, w);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttribI4iv(GLuint indx, const GLint* values) {
+static void GL_BINDING_CALL Debug_glVertexAttribI4iv(GLuint indx,
+                                                     const GLint* values) {
   GL_SERVICE_LOG("glVertexAttribI4iv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
@@ -4669,8 +4979,8 @@ Debug_glVertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w) {
   g_driver_gl.debug_fn.glVertexAttribI4uiFn(indx, x, y, z, w);
 }
 
-static void GL_BINDING_CALL
-Debug_glVertexAttribI4uiv(GLuint indx, const GLuint* values) {
+static void GL_BINDING_CALL Debug_glVertexAttribI4uiv(GLuint indx,
+                                                      const GLuint* values) {
   GL_SERVICE_LOG("glVertexAttribI4uiv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
@@ -4704,16 +5014,19 @@ static void GL_BINDING_CALL Debug_glVertexAttribPointer(GLuint indx,
                                                stride, ptr);
 }
 
-static void GL_BINDING_CALL
-Debug_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+static void GL_BINDING_CALL Debug_glViewport(GLint x,
+                                             GLint y,
+                                             GLsizei width,
+                                             GLsizei height) {
   GL_SERVICE_LOG("glViewport"
                  << "(" << x << ", " << y << ", " << width << ", " << height
                  << ")");
   g_driver_gl.debug_fn.glViewportFn(x, y, width, height);
 }
 
-static GLenum GL_BINDING_CALL
-Debug_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+static GLenum GL_BINDING_CALL Debug_glWaitSync(GLsync sync,
+                                               GLbitfield flags,
+                                               GLuint64 timeout) {
   GL_SERVICE_LOG("glWaitSync"
                  << "(" << sync << ", " << flags << ", " << timeout << ")");
   GLenum result = g_driver_gl.debug_fn.glWaitSyncFn(sync, flags, timeout);
@@ -4727,6 +5040,12 @@ void DriverGL::InitializeDebugBindings() {
     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;
@@ -4916,6 +5235,14 @@ void DriverGL::InitializeDebugBindings() {
     debug_fn.glCopyTexSubImage3DFn = fn.glCopyTexSubImage3DFn;
     fn.glCopyTexSubImage3DFn = Debug_glCopyTexSubImage3D;
   }
+  if (!debug_fn.glCoverFillPathNVFn) {
+    debug_fn.glCoverFillPathNVFn = fn.glCoverFillPathNVFn;
+    fn.glCoverFillPathNVFn = Debug_glCoverFillPathNV;
+  }
+  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;
@@ -4944,6 +5271,10 @@ void DriverGL::InitializeDebugBindings() {
     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;
@@ -5138,6 +5469,10 @@ void DriverGL::InitializeDebugBindings() {
     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;
@@ -5421,6 +5756,10 @@ void DriverGL::InitializeDebugBindings() {
     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;
@@ -5481,6 +5820,22 @@ void DriverGL::InitializeDebugBindings() {
     debug_fn.glMatrixLoadIdentityEXTFn = fn.glMatrixLoadIdentityEXTFn;
     fn.glMatrixLoadIdentityEXTFn = Debug_glMatrixLoadIdentityEXT;
   }
+  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;
@@ -5601,6 +5956,10 @@ void DriverGL::InitializeDebugBindings() {
     debug_fn.glShaderSourceFn = fn.glShaderSourceFn;
     fn.glShaderSourceFn = Debug_glShaderSource;
   }
+  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;
@@ -5625,6 +5984,19 @@ void DriverGL::InitializeDebugBindings() {
     debug_fn.glStencilOpSeparateFn = fn.glStencilOpSeparateFn;
     fn.glStencilOpSeparateFn = Debug_glStencilOpSeparate;
   }
+  if (!debug_fn.glStencilStrokePathNVFn) {
+    debug_fn.glStencilStrokePathNVFn = fn.glStencilStrokePathNVFn;
+    fn.glStencilStrokePathNVFn = Debug_glStencilStrokePathNV;
+  }
+  if (!debug_fn.glStencilThenCoverFillPathNVFn) {
+    debug_fn.glStencilThenCoverFillPathNVFn = fn.glStencilThenCoverFillPathNVFn;
+    fn.glStencilThenCoverFillPathNVFn = Debug_glStencilThenCoverFillPathNV;
+  }
+  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;
@@ -5904,6 +6276,10 @@ void GLApiBase::glActiveTextureFn(GLenum texture) {
   driver_->fn.glActiveTextureFn(texture);
 }
 
+void GLApiBase::glApplyFramebufferAttachmentCMAAINTELFn(void) {
+  driver_->fn.glApplyFramebufferAttachmentCMAAINTELFn();
+}
+
 void GLApiBase::glAttachShaderFn(GLuint program, GLuint shader) {
   driver_->fn.glAttachShaderFn(program, shader);
 }
@@ -6231,6 +6607,14 @@ void GLApiBase::glCopyTexSubImage3DFn(GLenum target,
                                     y, width, height);
 }
 
+void GLApiBase::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+  driver_->fn.glCoverFillPathNVFn(path, coverMode);
+}
+
+void GLApiBase::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+  driver_->fn.glCoverStrokePathNVFn(name, coverMode);
+}
+
 GLuint GLApiBase::glCreateProgramFn(void) {
   return driver_->fn.glCreateProgramFn();
 }
@@ -6260,6 +6644,10 @@ void GLApiBase::glDeleteFramebuffersEXTFn(GLsizei n,
   driver_->fn.glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
+void GLApiBase::glDeletePathsNVFn(GLuint path, GLsizei range) {
+  driver_->fn.glDeletePathsNVFn(path, range);
+}
+
 void GLApiBase::glDeleteProgramFn(GLuint program) {
   driver_->fn.glDeleteProgramFn(program);
 }
@@ -6497,6 +6885,10 @@ void GLApiBase::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
   driver_->fn.glGenFramebuffersEXTFn(n, framebuffers);
 }
 
+GLuint GLApiBase::glGenPathsNVFn(GLsizei range) {
+  return driver_->fn.glGenPathsNVFn(range);
+}
+
 void GLApiBase::glGenQueriesFn(GLsizei n, GLuint* ids) {
   driver_->fn.glGenQueriesFn(n, ids);
 }
@@ -6899,6 +7291,10 @@ GLboolean GLApiBase::glIsFramebufferEXTFn(GLuint framebuffer) {
   return driver_->fn.glIsFramebufferEXTFn(framebuffer);
 }
 
+GLboolean GLApiBase::glIsPathNVFn(GLuint path) {
+  return driver_->fn.glIsPathNVFn(path);
+}
+
 GLboolean GLApiBase::glIsProgramFn(GLuint program) {
   return driver_->fn.glIsProgramFn(program);
 }
@@ -6962,6 +7358,28 @@ void GLApiBase::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
   driver_->fn.glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
+void GLApiBase::glPathCommandsNVFn(GLuint path,
+                                   GLsizei numCommands,
+                                   const GLubyte* commands,
+                                   GLsizei numCoords,
+                                   GLenum coordType,
+                                   const GLvoid* coords) {
+  driver_->fn.glPathCommandsNVFn(path, numCommands, commands, numCoords,
+                                 coordType, coords);
+}
+
+void GLApiBase::glPathParameterfNVFn(GLuint path, GLenum pname, GLfloat value) {
+  driver_->fn.glPathParameterfNVFn(path, pname, value);
+}
+
+void GLApiBase::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
+  driver_->fn.glPathParameteriNVFn(path, pname, value);
+}
+
+void GLApiBase::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
+  driver_->fn.glPathStencilFuncNVFn(func, ref, mask);
+}
+
 void GLApiBase::glPauseTransformFeedbackFn(void) {
   driver_->fn.glPauseTransformFeedbackFn();
 }
@@ -7123,6 +7541,12 @@ void GLApiBase::glShaderSourceFn(GLuint shader,
   driver_->fn.glShaderSourceFn(shader, count, str, length);
 }
 
+void GLApiBase::glStencilFillPathNVFn(GLuint path,
+                                      GLenum fillMode,
+                                      GLuint mask) {
+  driver_->fn.glStencilFillPathNVFn(path, fillMode, mask);
+}
+
 void GLApiBase::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   driver_->fn.glStencilFuncFn(func, ref, mask);
 }
@@ -7153,6 +7577,27 @@ void GLApiBase::glStencilOpSeparateFn(GLenum face,
   driver_->fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
+void GLApiBase::glStencilStrokePathNVFn(GLuint path,
+                                        GLint reference,
+                                        GLuint mask) {
+  driver_->fn.glStencilStrokePathNVFn(path, reference, mask);
+}
+
+void GLApiBase::glStencilThenCoverFillPathNVFn(GLuint path,
+                                               GLenum fillMode,
+                                               GLuint mask,
+                                               GLenum coverMode) {
+  driver_->fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
+}
+
+void GLApiBase::glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                 GLint reference,
+                                                 GLuint mask,
+                                                 GLenum coverMode) {
+  driver_->fn.glStencilThenCoverStrokePathNVFn(path, reference, mask,
+                                               coverMode);
+}
+
 GLboolean GLApiBase::glTestFenceAPPLEFn(GLuint fence) {
   return driver_->fn.glTestFenceAPPLEFn(fence);
 }
@@ -7572,6 +8017,12 @@ void TraceGLApi::glActiveTextureFn(GLenum texture) {
   gl_api_->glActiveTextureFn(texture);
 }
 
+void TraceGLApi::glApplyFramebufferAttachmentCMAAINTELFn(void) {
+  TRACE_EVENT_BINARY_EFFICIENT0(
+      "gpu", "TraceGLAPI::glApplyFramebufferAttachmentCMAAINTEL")
+  gl_api_->glApplyFramebufferAttachmentCMAAINTELFn();
+}
+
 void TraceGLApi::glAttachShaderFn(GLuint program, GLuint shader) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glAttachShader")
   gl_api_->glAttachShaderFn(program, shader);
@@ -7949,6 +8400,16 @@ void TraceGLApi::glCopyTexSubImage3DFn(GLenum target,
                                  width, height);
 }
 
+void TraceGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverFillPathNV")
+  gl_api_->glCoverFillPathNVFn(path, coverMode);
+}
+
+void TraceGLApi::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverStrokePathNV")
+  gl_api_->glCoverStrokePathNVFn(name, coverMode);
+}
+
 GLuint TraceGLApi::glCreateProgramFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCreateProgram")
   return gl_api_->glCreateProgramFn();
@@ -7985,6 +8446,11 @@ void TraceGLApi::glDeleteFramebuffersEXTFn(GLsizei n,
   gl_api_->glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
+void TraceGLApi::glDeletePathsNVFn(GLuint path, GLsizei range) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeletePathsNV")
+  gl_api_->glDeletePathsNVFn(path, range);
+}
+
 void TraceGLApi::glDeleteProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteProgram")
   gl_api_->glDeleteProgramFn(program);
@@ -8275,6 +8741,11 @@ void TraceGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
   gl_api_->glGenFramebuffersEXTFn(n, framebuffers);
 }
 
+GLuint TraceGLApi::glGenPathsNVFn(GLsizei range) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenPathsNV")
+  return gl_api_->glGenPathsNVFn(range);
+}
+
 void TraceGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenQueries")
   gl_api_->glGenQueriesFn(n, ids);
@@ -8753,6 +9224,11 @@ GLboolean TraceGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
   return gl_api_->glIsFramebufferEXTFn(framebuffer);
 }
 
+GLboolean TraceGLApi::glIsPathNVFn(GLuint path) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsPathNV")
+  return gl_api_->glIsPathNVFn(path);
+}
+
 GLboolean TraceGLApi::glIsProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsProgram")
   return gl_api_->glIsProgramFn(program);
@@ -8831,6 +9307,34 @@ void TraceGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
   gl_api_->glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
+void TraceGLApi::glPathCommandsNVFn(GLuint path,
+                                    GLsizei numCommands,
+                                    const GLubyte* commands,
+                                    GLsizei numCoords,
+                                    GLenum coordType,
+                                    const GLvoid* coords) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathCommandsNV")
+  gl_api_->glPathCommandsNVFn(path, numCommands, commands, numCoords, coordType,
+                              coords);
+}
+
+void TraceGLApi::glPathParameterfNVFn(GLuint path,
+                                      GLenum pname,
+                                      GLfloat value) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathParameterfNV")
+  gl_api_->glPathParameterfNVFn(path, pname, value);
+}
+
+void TraceGLApi::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathParameteriNV")
+  gl_api_->glPathParameteriNVFn(path, pname, value);
+}
+
+void TraceGLApi::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathStencilFuncNV")
+  gl_api_->glPathStencilFuncNVFn(func, ref, mask);
+}
+
 void TraceGLApi::glPauseTransformFeedbackFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPauseTransformFeedback")
   gl_api_->glPauseTransformFeedbackFn();
@@ -9024,6 +9528,13 @@ void TraceGLApi::glShaderSourceFn(GLuint shader,
   gl_api_->glShaderSourceFn(shader, count, str, length);
 }
 
+void TraceGLApi::glStencilFillPathNVFn(GLuint path,
+                                       GLenum fillMode,
+                                       GLuint mask) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFillPathNV")
+  gl_api_->glStencilFillPathNVFn(path, fillMode, mask);
+}
+
 void TraceGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFunc")
   gl_api_->glStencilFuncFn(func, ref, mask);
@@ -9060,6 +9571,31 @@ void TraceGLApi::glStencilOpSeparateFn(GLenum face,
   gl_api_->glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
+void TraceGLApi::glStencilStrokePathNVFn(GLuint path,
+                                         GLint reference,
+                                         GLuint mask) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilStrokePathNV")
+  gl_api_->glStencilStrokePathNVFn(path, reference, mask);
+}
+
+void TraceGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
+                                                GLenum fillMode,
+                                                GLuint mask,
+                                                GLenum coverMode) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::glStencilThenCoverFillPathNV")
+  gl_api_->glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
+}
+
+void TraceGLApi::glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                  GLint reference,
+                                                  GLuint mask,
+                                                  GLenum coverMode) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::glStencilThenCoverStrokePathNV")
+  gl_api_->glStencilThenCoverStrokePathNVFn(path, reference, mask, coverMode);
+}
+
 GLboolean TraceGLApi::glTestFenceAPPLEFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTestFenceAPPLE")
   return gl_api_->glTestFenceAPPLEFn(fence);
@@ -9547,6 +10083,13 @@ void NoContextGLApi::glActiveTextureFn(GLenum texture) {
   LOG(ERROR) << "Trying to call glActiveTexture() without current GL context";
 }
 
+void NoContextGLApi::glApplyFramebufferAttachmentCMAAINTELFn(void) {
+  NOTREACHED() << "Trying to call glApplyFramebufferAttachmentCMAAINTEL() "
+                  "without current GL context";
+  LOG(ERROR) << "Trying to call glApplyFramebufferAttachmentCMAAINTEL() "
+                "without current GL context";
+}
+
 void NoContextGLApi::glAttachShaderFn(GLuint program, GLuint shader) {
   NOTREACHED() << "Trying to call glAttachShader() without current GL context";
   LOG(ERROR) << "Trying to call glAttachShader() without current GL context";
@@ -9961,6 +10504,19 @@ void NoContextGLApi::glCopyTexSubImage3DFn(GLenum target,
       << "Trying to call glCopyTexSubImage3D() without current GL context";
 }
 
+void NoContextGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+  NOTREACHED()
+      << "Trying to call glCoverFillPathNV() without current GL context";
+  LOG(ERROR) << "Trying to call glCoverFillPathNV() without current GL context";
+}
+
+void NoContextGLApi::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+  NOTREACHED()
+      << "Trying to call glCoverStrokePathNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glCoverStrokePathNV() without current GL context";
+}
+
 GLuint NoContextGLApi::glCreateProgramFn(void) {
   NOTREACHED() << "Trying to call glCreateProgram() without current GL context";
   LOG(ERROR) << "Trying to call glCreateProgram() without current GL context";
@@ -10006,6 +10562,11 @@ void NoContextGLApi::glDeleteFramebuffersEXTFn(GLsizei n,
       << "Trying to call glDeleteFramebuffersEXT() without current GL context";
 }
 
+void NoContextGLApi::glDeletePathsNVFn(GLuint path, GLsizei range) {
+  NOTREACHED() << "Trying to call glDeletePathsNV() without current GL context";
+  LOG(ERROR) << "Trying to call glDeletePathsNV() without current GL context";
+}
+
 void NoContextGLApi::glDeleteProgramFn(GLuint program) {
   NOTREACHED() << "Trying to call glDeleteProgram() without current GL context";
   LOG(ERROR) << "Trying to call glDeleteProgram() without current GL context";
@@ -10334,6 +10895,12 @@ void NoContextGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
       << "Trying to call glGenFramebuffersEXT() without current GL context";
 }
 
+GLuint NoContextGLApi::glGenPathsNVFn(GLsizei range) {
+  NOTREACHED() << "Trying to call glGenPathsNV() without current GL context";
+  LOG(ERROR) << "Trying to call glGenPathsNV() without current GL context";
+  return 0U;
+}
+
 void NoContextGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
   NOTREACHED() << "Trying to call glGenQueries() without current GL context";
   LOG(ERROR) << "Trying to call glGenQueries() without current GL context";
@@ -10909,6 +11476,12 @@ GLboolean NoContextGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
   return GL_FALSE;
 }
 
+GLboolean NoContextGLApi::glIsPathNVFn(GLuint path) {
+  NOTREACHED() << "Trying to call glIsPathNV() without current GL context";
+  LOG(ERROR) << "Trying to call glIsPathNV() without current GL context";
+  return GL_FALSE;
+}
+
 GLboolean NoContextGLApi::glIsProgramFn(GLuint program) {
   NOTREACHED() << "Trying to call glIsProgram() without current GL context";
   LOG(ERROR) << "Trying to call glIsProgram() without current GL context";
@@ -11008,6 +11581,44 @@ void NoContextGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
       << "Trying to call glMatrixLoadIdentityEXT() without current GL context";
 }
 
+void NoContextGLApi::glPathCommandsNVFn(GLuint path,
+                                        GLsizei numCommands,
+                                        const GLubyte* commands,
+                                        GLsizei numCoords,
+                                        GLenum coordType,
+                                        const GLvoid* coords) {
+  NOTREACHED()
+      << "Trying to call glPathCommandsNV() without current GL context";
+  LOG(ERROR) << "Trying to call glPathCommandsNV() without current GL context";
+}
+
+void NoContextGLApi::glPathParameterfNVFn(GLuint path,
+                                          GLenum pname,
+                                          GLfloat value) {
+  NOTREACHED()
+      << "Trying to call glPathParameterfNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glPathParameterfNV() without current GL context";
+}
+
+void NoContextGLApi::glPathParameteriNVFn(GLuint path,
+                                          GLenum pname,
+                                          GLint value) {
+  NOTREACHED()
+      << "Trying to call glPathParameteriNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glPathParameteriNV() without current GL context";
+}
+
+void NoContextGLApi::glPathStencilFuncNVFn(GLenum func,
+                                           GLint ref,
+                                           GLuint mask) {
+  NOTREACHED()
+      << "Trying to call glPathStencilFuncNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glPathStencilFuncNV() without current GL context";
+}
+
 void NoContextGLApi::glPauseTransformFeedbackFn(void) {
   NOTREACHED()
       << "Trying to call glPauseTransformFeedback() without current GL context";
@@ -11232,6 +11843,15 @@ void NoContextGLApi::glShaderSourceFn(GLuint shader,
   LOG(ERROR) << "Trying to call glShaderSource() without current GL context";
 }
 
+void NoContextGLApi::glStencilFillPathNVFn(GLuint path,
+                                           GLenum fillMode,
+                                           GLuint mask) {
+  NOTREACHED()
+      << "Trying to call glStencilFillPathNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glStencilFillPathNV() without current GL context";
+}
+
 void NoContextGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   NOTREACHED() << "Trying to call glStencilFunc() without current GL context";
   LOG(ERROR) << "Trying to call glStencilFunc() without current GL context";
@@ -11274,6 +11894,35 @@ void NoContextGLApi::glStencilOpSeparateFn(GLenum face,
       << "Trying to call glStencilOpSeparate() without current GL context";
 }
 
+void NoContextGLApi::glStencilStrokePathNVFn(GLuint path,
+                                             GLint reference,
+                                             GLuint mask) {
+  NOTREACHED()
+      << "Trying to call glStencilStrokePathNV() without current GL context";
+  LOG(ERROR)
+      << "Trying to call glStencilStrokePathNV() without current GL context";
+}
+
+void NoContextGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
+                                                    GLenum fillMode,
+                                                    GLuint mask,
+                                                    GLenum coverMode) {
+  NOTREACHED() << "Trying to call glStencilThenCoverFillPathNV() without "
+                  "current GL context";
+  LOG(ERROR) << "Trying to call glStencilThenCoverFillPathNV() without current "
+                "GL context";
+}
+
+void NoContextGLApi::glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                      GLint reference,
+                                                      GLuint mask,
+                                                      GLenum coverMode) {
+  NOTREACHED() << "Trying to call glStencilThenCoverStrokePathNV() without "
+                  "current GL context";
+  LOG(ERROR) << "Trying to call glStencilThenCoverStrokePathNV() without "
+                "current GL context";
+}
+
 GLboolean NoContextGLApi::glTestFenceAPPLEFn(GLuint fence) {
   NOTREACHED()
       << "Trying to call glTestFenceAPPLE() without current GL context";
diff --git a/chromium/ui/gl/gl_bindings_autogen_gl.h b/chromium/ui/gl/gl_bindings_autogen_gl.h
index 1689361c39e..15a95186af7 100644
--- a/chromium/ui/gl/gl_bindings_autogen_gl.h
+++ b/chromium/ui/gl/gl_bindings_autogen_gl.h
@@ -16,6 +16,7 @@ namespace gfx {
 class GLContext;
 
 typedef void(GL_BINDING_CALL* glActiveTextureProc)(GLenum texture);
+typedef void(GL_BINDING_CALL* glApplyFramebufferAttachmentCMAAINTELProc)(void);
 typedef void(GL_BINDING_CALL* glAttachShaderProc)(GLuint program,
                                                   GLuint shader);
 typedef void(GL_BINDING_CALL* glBeginQueryProc)(GLenum target, GLuint id);
@@ -198,6 +199,10 @@ typedef void(GL_BINDING_CALL* glCopyTexSubImage3DProc)(GLenum target,
                                                        GLint y,
                                                        GLsizei width,
                                                        GLsizei height);
+typedef void(GL_BINDING_CALL* glCoverFillPathNVProc)(GLuint path,
+                                                     GLenum coverMode);
+typedef void(GL_BINDING_CALL* glCoverStrokePathNVProc)(GLuint name,
+                                                       GLenum coverMode);
 typedef GLuint(GL_BINDING_CALL* glCreateProgramProc)(void);
 typedef GLuint(GL_BINDING_CALL* glCreateShaderProc)(GLenum type);
 typedef void(GL_BINDING_CALL* glCullFaceProc)(GLenum mode);
@@ -210,6 +215,7 @@ typedef void(GL_BINDING_CALL* glDeleteFencesNVProc)(GLsizei n,
 typedef void(GL_BINDING_CALL* glDeleteFramebuffersEXTProc)(
     GLsizei n,
     const GLuint* framebuffers);
+typedef void(GL_BINDING_CALL* glDeletePathsNVProc)(GLuint path, GLsizei range);
 typedef void(GL_BINDING_CALL* glDeleteProgramProc)(GLuint program);
 typedef void(GL_BINDING_CALL* glDeleteQueriesProc)(GLsizei n,
                                                    const GLuint* ids);
@@ -322,6 +328,7 @@ typedef void(GL_BINDING_CALL* glGenFencesAPPLEProc)(GLsizei n, GLuint* fences);
 typedef void(GL_BINDING_CALL* glGenFencesNVProc)(GLsizei n, GLuint* fences);
 typedef void(GL_BINDING_CALL* glGenFramebuffersEXTProc)(GLsizei n,
                                                         GLuint* framebuffers);
+typedef GLuint(GL_BINDING_CALL* glGenPathsNVProc)(GLsizei range);
 typedef void(GL_BINDING_CALL* glGenQueriesProc)(GLsizei n, GLuint* ids);
 typedef void(GL_BINDING_CALL* glGenRenderbuffersEXTProc)(GLsizei n,
                                                          GLuint* renderbuffers);
@@ -540,6 +547,7 @@ typedef GLboolean(GL_BINDING_CALL* glIsEnabledProc)(GLenum cap);
 typedef GLboolean(GL_BINDING_CALL* glIsFenceAPPLEProc)(GLuint fence);
 typedef GLboolean(GL_BINDING_CALL* glIsFenceNVProc)(GLuint fence);
 typedef GLboolean(GL_BINDING_CALL* glIsFramebufferEXTProc)(GLuint framebuffer);
+typedef GLboolean(GL_BINDING_CALL* glIsPathNVProc)(GLuint path);
 typedef GLboolean(GL_BINDING_CALL* glIsProgramProc)(GLuint program);
 typedef GLboolean(GL_BINDING_CALL* glIsQueryProc)(GLuint query);
 typedef GLboolean(GL_BINDING_CALL* glIsRenderbufferEXTProc)(
@@ -560,6 +568,21 @@ typedef void*(GL_BINDING_CALL* glMapBufferRangeProc)(GLenum target,
 typedef void(GL_BINDING_CALL* glMatrixLoadfEXTProc)(GLenum matrixMode,
                                                     const GLfloat* m);
 typedef void(GL_BINDING_CALL* glMatrixLoadIdentityEXTProc)(GLenum matrixMode);
+typedef void(GL_BINDING_CALL* glPathCommandsNVProc)(GLuint path,
+                                                    GLsizei numCommands,
+                                                    const GLubyte* commands,
+                                                    GLsizei numCoords,
+                                                    GLenum coordType,
+                                                    const GLvoid* coords);
+typedef void(GL_BINDING_CALL* glPathParameterfNVProc)(GLuint path,
+                                                      GLenum pname,
+                                                      GLfloat value);
+typedef void(GL_BINDING_CALL* glPathParameteriNVProc)(GLuint path,
+                                                      GLenum pname,
+                                                      GLint value);
+typedef void(GL_BINDING_CALL* glPathStencilFuncNVProc)(GLenum func,
+                                                       GLint ref,
+                                                       GLuint mask);
 typedef void(GL_BINDING_CALL* glPauseTransformFeedbackProc)(void);
 typedef void(GL_BINDING_CALL* glPixelStoreiProc)(GLenum pname, GLint param);
 typedef void(GL_BINDING_CALL* glPointParameteriProc)(GLenum pname, GLint param);
@@ -644,6 +667,9 @@ typedef void(GL_BINDING_CALL* glShaderSourceProc)(GLuint shader,
                                                   GLsizei count,
                                                   const char* const* str,
                                                   const GLint* length);
+typedef void(GL_BINDING_CALL* glStencilFillPathNVProc)(GLuint path,
+                                                       GLenum fillMode,
+                                                       GLuint mask);
 typedef void(GL_BINDING_CALL* glStencilFuncProc)(GLenum func,
                                                  GLint ref,
                                                  GLuint mask);
@@ -661,6 +687,19 @@ typedef void(GL_BINDING_CALL* glStencilOpSeparateProc)(GLenum face,
                                                        GLenum fail,
                                                        GLenum zfail,
                                                        GLenum zpass);
+typedef void(GL_BINDING_CALL* glStencilStrokePathNVProc)(GLuint path,
+                                                         GLint reference,
+                                                         GLuint mask);
+typedef void(GL_BINDING_CALL* glStencilThenCoverFillPathNVProc)(
+    GLuint path,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum coverMode);
+typedef void(GL_BINDING_CALL* glStencilThenCoverStrokePathNVProc)(
+    GLuint path,
+    GLint reference,
+    GLuint mask,
+    GLenum coverMode);
 typedef GLboolean(GL_BINDING_CALL* glTestFenceAPPLEProc)(GLuint fence);
 typedef GLboolean(GL_BINDING_CALL* glTestFenceNVProc)(GLuint fence);
 typedef void(GL_BINDING_CALL* glTexImage2DProc)(GLenum target,
@@ -939,6 +978,7 @@ struct ExtensionsGL {
   bool b_GL_EXT_texture_storage;
   bool b_GL_EXT_timer_query;
   bool b_GL_IMG_multisampled_render_to_texture;
+  bool b_GL_INTEL_framebuffer_CMAA;
   bool b_GL_KHR_blend_equation_advanced;
   bool b_GL_KHR_robustness;
   bool b_GL_NV_blend_equation_advanced;
@@ -952,6 +992,8 @@ struct ExtensionsGL {
 
 struct ProcsGL {
   glActiveTextureProc glActiveTextureFn;
+  glApplyFramebufferAttachmentCMAAINTELProc
+      glApplyFramebufferAttachmentCMAAINTELFn;
   glAttachShaderProc glAttachShaderFn;
   glBeginQueryProc glBeginQueryFn;
   glBeginTransformFeedbackProc glBeginTransformFeedbackFn;
@@ -999,6 +1041,8 @@ struct ProcsGL {
   glCopyTexImage2DProc glCopyTexImage2DFn;
   glCopyTexSubImage2DProc glCopyTexSubImage2DFn;
   glCopyTexSubImage3DProc glCopyTexSubImage3DFn;
+  glCoverFillPathNVProc glCoverFillPathNVFn;
+  glCoverStrokePathNVProc glCoverStrokePathNVFn;
   glCreateProgramProc glCreateProgramFn;
   glCreateShaderProc glCreateShaderFn;
   glCullFaceProc glCullFaceFn;
@@ -1006,6 +1050,7 @@ struct ProcsGL {
   glDeleteFencesAPPLEProc glDeleteFencesAPPLEFn;
   glDeleteFencesNVProc glDeleteFencesNVFn;
   glDeleteFramebuffersEXTProc glDeleteFramebuffersEXTFn;
+  glDeletePathsNVProc glDeletePathsNVFn;
   glDeleteProgramProc glDeleteProgramFn;
   glDeleteQueriesProc glDeleteQueriesFn;
   glDeleteRenderbuffersEXTProc glDeleteRenderbuffersEXTFn;
@@ -1056,6 +1101,7 @@ struct ProcsGL {
   glGenFencesAPPLEProc glGenFencesAPPLEFn;
   glGenFencesNVProc glGenFencesNVFn;
   glGenFramebuffersEXTProc glGenFramebuffersEXTFn;
+  glGenPathsNVProc glGenPathsNVFn;
   glGenQueriesProc glGenQueriesFn;
   glGenRenderbuffersEXTProc glGenRenderbuffersEXTFn;
   glGenSamplersProc glGenSamplersFn;
@@ -1126,6 +1172,7 @@ struct ProcsGL {
   glIsFenceAPPLEProc glIsFenceAPPLEFn;
   glIsFenceNVProc glIsFenceNVFn;
   glIsFramebufferEXTProc glIsFramebufferEXTFn;
+  glIsPathNVProc glIsPathNVFn;
   glIsProgramProc glIsProgramFn;
   glIsQueryProc glIsQueryFn;
   glIsRenderbufferEXTProc glIsRenderbufferEXTFn;
@@ -1141,6 +1188,10 @@ struct ProcsGL {
   glMapBufferRangeProc glMapBufferRangeFn;
   glMatrixLoadfEXTProc glMatrixLoadfEXTFn;
   glMatrixLoadIdentityEXTProc glMatrixLoadIdentityEXTFn;
+  glPathCommandsNVProc glPathCommandsNVFn;
+  glPathParameterfNVProc glPathParameterfNVFn;
+  glPathParameteriNVProc glPathParameteriNVFn;
+  glPathStencilFuncNVProc glPathStencilFuncNVFn;
   glPauseTransformFeedbackProc glPauseTransformFeedbackFn;
   glPixelStoreiProc glPixelStoreiFn;
   glPointParameteriProc glPointParameteriFn;
@@ -1170,12 +1221,16 @@ struct ProcsGL {
   glSetFenceNVProc glSetFenceNVFn;
   glShaderBinaryProc glShaderBinaryFn;
   glShaderSourceProc glShaderSourceFn;
+  glStencilFillPathNVProc glStencilFillPathNVFn;
   glStencilFuncProc glStencilFuncFn;
   glStencilFuncSeparateProc glStencilFuncSeparateFn;
   glStencilMaskProc glStencilMaskFn;
   glStencilMaskSeparateProc glStencilMaskSeparateFn;
   glStencilOpProc glStencilOpFn;
   glStencilOpSeparateProc glStencilOpSeparateFn;
+  glStencilStrokePathNVProc glStencilStrokePathNVFn;
+  glStencilThenCoverFillPathNVProc glStencilThenCoverFillPathNVFn;
+  glStencilThenCoverStrokePathNVProc glStencilThenCoverStrokePathNVFn;
   glTestFenceAPPLEProc glTestFenceAPPLEFn;
   glTestFenceNVProc glTestFenceNVFn;
   glTexImage2DProc glTexImage2DFn;
@@ -1251,6 +1306,7 @@ class GL_EXPORT GLApi {
   virtual ~GLApi();
 
   virtual void glActiveTextureFn(GLenum texture) = 0;
+  virtual void glApplyFramebufferAttachmentCMAAINTELFn(void) = 0;
   virtual void glAttachShaderFn(GLuint program, GLuint shader) = 0;
   virtual void glBeginQueryFn(GLenum target, GLuint id) = 0;
   virtual void glBeginTransformFeedbackFn(GLenum primitiveMode) = 0;
@@ -1426,6 +1482,8 @@ class GL_EXPORT GLApi {
                                      GLint y,
                                      GLsizei width,
                                      GLsizei height) = 0;
+  virtual void glCoverFillPathNVFn(GLuint path, GLenum coverMode) = 0;
+  virtual void glCoverStrokePathNVFn(GLuint name, GLenum coverMode) = 0;
   virtual GLuint glCreateProgramFn(void) = 0;
   virtual GLuint glCreateShaderFn(GLenum type) = 0;
   virtual void glCullFaceFn(GLenum mode) = 0;
@@ -1434,6 +1492,7 @@ class GL_EXPORT GLApi {
   virtual void glDeleteFencesNVFn(GLsizei n, const GLuint* fences) = 0;
   virtual void glDeleteFramebuffersEXTFn(GLsizei n,
                                          const GLuint* framebuffers) = 0;
+  virtual void glDeletePathsNVFn(GLuint path, GLsizei range) = 0;
   virtual void glDeleteProgramFn(GLuint program) = 0;
   virtual void glDeleteQueriesFn(GLsizei n, const GLuint* ids) = 0;
   virtual void glDeleteRenderbuffersEXTFn(GLsizei n,
@@ -1525,6 +1584,7 @@ class GL_EXPORT GLApi {
   virtual void glGenFencesAPPLEFn(GLsizei n, GLuint* fences) = 0;
   virtual void glGenFencesNVFn(GLsizei n, GLuint* fences) = 0;
   virtual void glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) = 0;
+  virtual GLuint glGenPathsNVFn(GLsizei range) = 0;
   virtual void glGenQueriesFn(GLsizei n, GLuint* ids) = 0;
   virtual void glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) = 0;
   virtual void glGenSamplersFn(GLsizei n, GLuint* samplers) = 0;
@@ -1710,6 +1770,7 @@ class GL_EXPORT GLApi {
   virtual GLboolean glIsFenceAPPLEFn(GLuint fence) = 0;
   virtual GLboolean glIsFenceNVFn(GLuint fence) = 0;
   virtual GLboolean glIsFramebufferEXTFn(GLuint framebuffer) = 0;
+  virtual GLboolean glIsPathNVFn(GLuint path) = 0;
   virtual GLboolean glIsProgramFn(GLuint program) = 0;
   virtual GLboolean glIsQueryFn(GLuint query) = 0;
   virtual GLboolean glIsRenderbufferEXTFn(GLuint renderbuffer) = 0;
@@ -1728,6 +1789,17 @@ class GL_EXPORT GLApi {
                                    GLbitfield access) = 0;
   virtual void glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) = 0;
   virtual void glMatrixLoadIdentityEXTFn(GLenum matrixMode) = 0;
+  virtual void glPathCommandsNVFn(GLuint path,
+                                  GLsizei numCommands,
+                                  const GLubyte* commands,
+                                  GLsizei numCoords,
+                                  GLenum coordType,
+                                  const GLvoid* coords) = 0;
+  virtual void glPathParameterfNVFn(GLuint path,
+                                    GLenum pname,
+                                    GLfloat value) = 0;
+  virtual void glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) = 0;
+  virtual void glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) = 0;
   virtual void glPauseTransformFeedbackFn(void) = 0;
   virtual void glPixelStoreiFn(GLenum pname, GLint param) = 0;
   virtual void glPointParameteriFn(GLenum pname, GLint param) = 0;
@@ -1801,6 +1873,9 @@ class GL_EXPORT GLApi {
                                 GLsizei count,
                                 const char* const* str,
                                 const GLint* length) = 0;
+  virtual void glStencilFillPathNVFn(GLuint path,
+                                     GLenum fillMode,
+                                     GLuint mask) = 0;
   virtual void glStencilFuncFn(GLenum func, GLint ref, GLuint mask) = 0;
   virtual void glStencilFuncSeparateFn(GLenum face,
                                        GLenum func,
@@ -1813,6 +1888,17 @@ class GL_EXPORT GLApi {
                                      GLenum fail,
                                      GLenum zfail,
                                      GLenum zpass) = 0;
+  virtual void glStencilStrokePathNVFn(GLuint path,
+                                       GLint reference,
+                                       GLuint mask) = 0;
+  virtual void glStencilThenCoverFillPathNVFn(GLuint path,
+                                              GLenum fillMode,
+                                              GLuint mask,
+                                              GLenum coverMode) = 0;
+  virtual void glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                GLint reference,
+                                                GLuint mask,
+                                                GLenum coverMode) = 0;
   virtual GLboolean glTestFenceAPPLEFn(GLuint fence) = 0;
   virtual GLboolean glTestFenceNVFn(GLuint fence) = 0;
   virtual void glTexImage2DFn(GLenum target,
@@ -2038,6 +2124,8 @@ class GL_EXPORT GLApi {
 }  // namespace gfx
 
 #define glActiveTexture ::gfx::g_current_gl_context->glActiveTextureFn
+#define glApplyFramebufferAttachmentCMAAINTEL \
+  ::gfx::g_current_gl_context->glApplyFramebufferAttachmentCMAAINTELFn
 #define glAttachShader ::gfx::g_current_gl_context->glAttachShaderFn
 #define glBeginQuery ::gfx::g_current_gl_context->glBeginQueryFn
 #define glBeginTransformFeedback \
@@ -2097,6 +2185,8 @@ class GL_EXPORT GLApi {
 #define glCopyTexImage2D ::gfx::g_current_gl_context->glCopyTexImage2DFn
 #define glCopyTexSubImage2D ::gfx::g_current_gl_context->glCopyTexSubImage2DFn
 #define glCopyTexSubImage3D ::gfx::g_current_gl_context->glCopyTexSubImage3DFn
+#define glCoverFillPathNV ::gfx::g_current_gl_context->glCoverFillPathNVFn
+#define glCoverStrokePathNV ::gfx::g_current_gl_context->glCoverStrokePathNVFn
 #define glCreateProgram ::gfx::g_current_gl_context->glCreateProgramFn
 #define glCreateShader ::gfx::g_current_gl_context->glCreateShaderFn
 #define glCullFace ::gfx::g_current_gl_context->glCullFaceFn
@@ -2105,6 +2195,7 @@ class GL_EXPORT GLApi {
 #define glDeleteFencesNV ::gfx::g_current_gl_context->glDeleteFencesNVFn
 #define glDeleteFramebuffersEXT \
   ::gfx::g_current_gl_context->glDeleteFramebuffersEXTFn
+#define glDeletePathsNV ::gfx::g_current_gl_context->glDeletePathsNVFn
 #define glDeleteProgram ::gfx::g_current_gl_context->glDeleteProgramFn
 #define glDeleteQueries ::gfx::g_current_gl_context->glDeleteQueriesFn
 #define glDeleteRenderbuffersEXT \
@@ -2169,6 +2260,7 @@ class GL_EXPORT GLApi {
 #define glGenFencesAPPLE ::gfx::g_current_gl_context->glGenFencesAPPLEFn
 #define glGenFencesNV ::gfx::g_current_gl_context->glGenFencesNVFn
 #define glGenFramebuffersEXT ::gfx::g_current_gl_context->glGenFramebuffersEXTFn
+#define glGenPathsNV ::gfx::g_current_gl_context->glGenPathsNVFn
 #define glGenQueries ::gfx::g_current_gl_context->glGenQueriesFn
 #define glGenRenderbuffersEXT \
   ::gfx::g_current_gl_context->glGenRenderbuffersEXTFn
@@ -2263,6 +2355,7 @@ class GL_EXPORT GLApi {
 #define glIsFenceAPPLE ::gfx::g_current_gl_context->glIsFenceAPPLEFn
 #define glIsFenceNV ::gfx::g_current_gl_context->glIsFenceNVFn
 #define glIsFramebufferEXT ::gfx::g_current_gl_context->glIsFramebufferEXTFn
+#define glIsPathNV ::gfx::g_current_gl_context->glIsPathNVFn
 #define glIsProgram ::gfx::g_current_gl_context->glIsProgramFn
 #define glIsQuery ::gfx::g_current_gl_context->glIsQueryFn
 #define glIsRenderbufferEXT ::gfx::g_current_gl_context->glIsRenderbufferEXTFn
@@ -2280,6 +2373,10 @@ class GL_EXPORT GLApi {
 #define glMatrixLoadfEXT ::gfx::g_current_gl_context->glMatrixLoadfEXTFn
 #define glMatrixLoadIdentityEXT \
   ::gfx::g_current_gl_context->glMatrixLoadIdentityEXTFn
+#define glPathCommandsNV ::gfx::g_current_gl_context->glPathCommandsNVFn
+#define glPathParameterfNV ::gfx::g_current_gl_context->glPathParameterfNVFn
+#define glPathParameteriNV ::gfx::g_current_gl_context->glPathParameteriNVFn
+#define glPathStencilFuncNV ::gfx::g_current_gl_context->glPathStencilFuncNVFn
 #define glPauseTransformFeedback \
   ::gfx::g_current_gl_context->glPauseTransformFeedbackFn
 #define glPixelStorei ::gfx::g_current_gl_context->glPixelStoreiFn
@@ -2316,6 +2413,7 @@ class GL_EXPORT GLApi {
 #define glSetFenceNV ::gfx::g_current_gl_context->glSetFenceNVFn
 #define glShaderBinary ::gfx::g_current_gl_context->glShaderBinaryFn
 #define glShaderSource ::gfx::g_current_gl_context->glShaderSourceFn
+#define glStencilFillPathNV ::gfx::g_current_gl_context->glStencilFillPathNVFn
 #define glStencilFunc ::gfx::g_current_gl_context->glStencilFuncFn
 #define glStencilFuncSeparate \
   ::gfx::g_current_gl_context->glStencilFuncSeparateFn
@@ -2324,6 +2422,12 @@ class GL_EXPORT GLApi {
   ::gfx::g_current_gl_context->glStencilMaskSeparateFn
 #define glStencilOp ::gfx::g_current_gl_context->glStencilOpFn
 #define glStencilOpSeparate ::gfx::g_current_gl_context->glStencilOpSeparateFn
+#define glStencilStrokePathNV \
+  ::gfx::g_current_gl_context->glStencilStrokePathNVFn
+#define glStencilThenCoverFillPathNV \
+  ::gfx::g_current_gl_context->glStencilThenCoverFillPathNVFn
+#define glStencilThenCoverStrokePathNV \
+  ::gfx::g_current_gl_context->glStencilThenCoverStrokePathNVFn
 #define glTestFenceAPPLE ::gfx::g_current_gl_context->glTestFenceAPPLEFn
 #define glTestFenceNV ::gfx::g_current_gl_context->glTestFenceNVFn
 #define glTexImage2D ::gfx::g_current_gl_context->glTexImage2DFn
diff --git a/chromium/ui/gl/gl_bindings_autogen_glx.cc b/chromium/ui/gl/gl_bindings_autogen_glx.cc
index 0bd0d03d831..7c9c8c15d5b 100644
--- a/chromium/ui/gl/gl_bindings_autogen_glx.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_glx.cc
@@ -240,8 +240,9 @@ Debug_glXChooseFBConfig(Display* dpy,
   return result;
 }
 
-static XVisualInfo* GL_BINDING_CALL
-Debug_glXChooseVisual(Display* dpy, int screen, int* attribList) {
+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) << ")");
@@ -305,8 +306,9 @@ Debug_glXCreateContextAttribsARB(Display* dpy,
   return result;
 }
 
-static GLXPixmap GL_BINDING_CALL
-Debug_glXCreateGLXPixmap(Display* dpy, XVisualInfo* visual, Pixmap pixmap) {
+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 << ")");
@@ -373,47 +375,47 @@ static GLXWindow GL_BINDING_CALL Debug_glXCreateWindow(Display* dpy,
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glXDestroyContext(Display* dpy, GLXContext ctx) {
+static void GL_BINDING_CALL Debug_glXDestroyContext(Display* dpy,
+                                                    GLXContext ctx) {
   GL_SERVICE_LOG("glXDestroyContext"
                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
   g_driver_glx.debug_fn.glXDestroyContextFn(dpy, ctx);
 }
 
-static void GL_BINDING_CALL
-Debug_glXDestroyGLXPixmap(Display* dpy, GLXPixmap pixmap) {
+static void GL_BINDING_CALL Debug_glXDestroyGLXPixmap(Display* dpy,
+                                                      GLXPixmap pixmap) {
   GL_SERVICE_LOG("glXDestroyGLXPixmap"
                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
                  << ")");
   g_driver_glx.debug_fn.glXDestroyGLXPixmapFn(dpy, pixmap);
 }
 
-static void GL_BINDING_CALL
-Debug_glXDestroyPbuffer(Display* dpy, GLXPbuffer pbuf) {
+static void GL_BINDING_CALL Debug_glXDestroyPbuffer(Display* dpy,
+                                                    GLXPbuffer pbuf) {
   GL_SERVICE_LOG("glXDestroyPbuffer"
                  << "(" << static_cast<const void*>(dpy) << ", " << pbuf
                  << ")");
   g_driver_glx.debug_fn.glXDestroyPbufferFn(dpy, pbuf);
 }
 
-static void GL_BINDING_CALL
-Debug_glXDestroyPixmap(Display* dpy, GLXPixmap pixmap) {
+static void GL_BINDING_CALL Debug_glXDestroyPixmap(Display* dpy,
+                                                   GLXPixmap pixmap) {
   GL_SERVICE_LOG("glXDestroyPixmap"
                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
                  << ")");
   g_driver_glx.debug_fn.glXDestroyPixmapFn(dpy, pixmap);
 }
 
-static void GL_BINDING_CALL
-Debug_glXDestroyWindow(Display* dpy, GLXWindow window) {
+static void GL_BINDING_CALL Debug_glXDestroyWindow(Display* dpy,
+                                                   GLXWindow window) {
   GL_SERVICE_LOG("glXDestroyWindow"
                  << "(" << static_cast<const void*>(dpy) << ", " << window
                  << ")");
   g_driver_glx.debug_fn.glXDestroyWindowFn(dpy, window);
 }
 
-static const char* GL_BINDING_CALL
-Debug_glXGetClientString(Display* dpy, int name) {
+static const char* GL_BINDING_CALL Debug_glXGetClientString(Display* dpy,
+                                                            int name) {
   GL_SERVICE_LOG("glXGetClientString"
                  << "(" << static_cast<const void*>(dpy) << ", " << name
                  << ")");
@@ -422,8 +424,10 @@ Debug_glXGetClientString(Display* dpy, int name) {
   return result;
 }
 
-static int GL_BINDING_CALL
-Debug_glXGetConfig(Display* dpy, XVisualInfo* visual, int attrib, int* value) {
+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 << ", "
@@ -494,8 +498,9 @@ Debug_glXGetFBConfigFromVisualSGIX(Display* dpy, XVisualInfo* visualInfo) {
   return result;
 }
 
-static GLXFBConfig* GL_BINDING_CALL
-Debug_glXGetFBConfigs(Display* dpy, int screen, int* nelements) {
+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) << ")");
@@ -576,8 +581,9 @@ static int GL_BINDING_CALL Debug_glXMakeContextCurrent(Display* dpy,
   return result;
 }
 
-static int GL_BINDING_CALL
-Debug_glXMakeCurrent(Display* dpy, GLXDrawable drawable, GLXContext ctx) {
+static int GL_BINDING_CALL Debug_glXMakeCurrent(Display* dpy,
+                                                GLXDrawable drawable,
+                                                GLXContext ctx) {
   GL_SERVICE_LOG("glXMakeCurrent"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << ctx << ")");
@@ -586,8 +592,10 @@ Debug_glXMakeCurrent(Display* dpy, GLXDrawable drawable, GLXContext ctx) {
   return result;
 }
 
-static int GL_BINDING_CALL
-Debug_glXQueryContext(Display* dpy, GLXContext ctx, int attribute, int* value) {
+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)
@@ -609,8 +617,9 @@ static void GL_BINDING_CALL Debug_glXQueryDrawable(Display* dpy,
   g_driver_glx.debug_fn.glXQueryDrawableFn(dpy, draw, attribute, value);
 }
 
-static int GL_BINDING_CALL
-Debug_glXQueryExtension(Display* dpy, int* errorb, int* event) {
+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) << ", "
@@ -620,8 +629,8 @@ Debug_glXQueryExtension(Display* dpy, int* errorb, int* event) {
   return result;
 }
 
-static const char* GL_BINDING_CALL
-Debug_glXQueryExtensionsString(Display* dpy, int screen) {
+static const char* GL_BINDING_CALL Debug_glXQueryExtensionsString(Display* dpy,
+                                                                  int screen) {
   GL_SERVICE_LOG("glXQueryExtensionsString"
                  << "(" << static_cast<const void*>(dpy) << ", " << screen
                  << ")");
@@ -631,8 +640,9 @@ Debug_glXQueryExtensionsString(Display* dpy, int screen) {
   return result;
 }
 
-static const char* GL_BINDING_CALL
-Debug_glXQueryServerString(Display* dpy, int screen, int name) {
+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 << ")");
@@ -642,8 +652,9 @@ Debug_glXQueryServerString(Display* dpy, int screen, int name) {
   return result;
 }
 
-static int GL_BINDING_CALL
-Debug_glXQueryVersion(Display* dpy, int* maj, int* min) {
+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) << ", "
@@ -653,32 +664,35 @@ Debug_glXQueryVersion(Display* dpy, int* maj, int* min) {
   return result;
 }
 
-static void GL_BINDING_CALL
-Debug_glXReleaseTexImageEXT(Display* dpy, GLXDrawable drawable, int buffer) {
+static void GL_BINDING_CALL Debug_glXReleaseTexImageEXT(Display* dpy,
+                                                        GLXDrawable drawable,
+                                                        int buffer) {
   GL_SERVICE_LOG("glXReleaseTexImageEXT"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << buffer << ")");
   g_driver_glx.debug_fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer);
 }
 
-static void GL_BINDING_CALL
-Debug_glXSelectEvent(Display* dpy, GLXDrawable drawable, unsigned long mask) {
+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 << ")");
   g_driver_glx.debug_fn.glXSelectEventFn(dpy, drawable, mask);
 }
 
-static void GL_BINDING_CALL
-Debug_glXSwapBuffers(Display* dpy, GLXDrawable drawable) {
+static void GL_BINDING_CALL Debug_glXSwapBuffers(Display* dpy,
+                                                 GLXDrawable drawable) {
   GL_SERVICE_LOG("glXSwapBuffers"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ")");
   g_driver_glx.debug_fn.glXSwapBuffersFn(dpy, drawable);
 }
 
-static void GL_BINDING_CALL
-Debug_glXSwapIntervalEXT(Display* dpy, GLXDrawable drawable, int interval) {
+static void GL_BINDING_CALL Debug_glXSwapIntervalEXT(Display* dpy,
+                                                     GLXDrawable drawable,
+                                                     int interval) {
   GL_SERVICE_LOG("glXSwapIntervalEXT"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << interval << ")");
@@ -691,8 +705,10 @@ static void GL_BINDING_CALL Debug_glXSwapIntervalMESA(unsigned int interval) {
   g_driver_glx.debug_fn.glXSwapIntervalMESAFn(interval);
 }
 
-static void GL_BINDING_CALL
-Debug_glXUseXFont(Font font, int first, int count, int list) {
+static void GL_BINDING_CALL Debug_glXUseXFont(Font font,
+                                              int first,
+                                              int count,
+                                              int list) {
   GL_SERVICE_LOG("glXUseXFont"
                  << "(" << font << ", " << first << ", " << count << ", "
                  << list << ")");
@@ -706,8 +722,9 @@ static void GL_BINDING_CALL Debug_glXWaitGL(void) {
   g_driver_glx.debug_fn.glXWaitGLFn();
 }
 
-static int GL_BINDING_CALL
-Debug_glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int* count) {
+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) << ")");
diff --git a/chromium/ui/gl/gl_bindings_autogen_mock.cc b/chromium/ui/gl/gl_bindings_autogen_mock.cc
index b5a82eea674..41a38dfba36 100644
--- a/chromium/ui/gl/gl_bindings_autogen_mock.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_mock.cc
@@ -27,25 +27,31 @@ void GL_BINDING_CALL MockGLInterface::Mock_glActiveTexture(GLenum texture) {
 }
 
 void GL_BINDING_CALL
-MockGLInterface::Mock_glAttachShader(GLuint program, GLuint shader) {
+MockGLInterface::Mock_glApplyFramebufferAttachmentCMAAINTEL(void) {
+  MakeFunctionUnique("glApplyFramebufferAttachmentCMAAINTEL");
+  interface_->ApplyFramebufferAttachmentCMAAINTEL();
+}
+
+void GL_BINDING_CALL MockGLInterface::Mock_glAttachShader(GLuint program,
+                                                          GLuint shader) {
   MakeFunctionUnique("glAttachShader");
   interface_->AttachShader(program, shader);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glBeginQuery(GLenum target, GLuint id) {
+void GL_BINDING_CALL MockGLInterface::Mock_glBeginQuery(GLenum target,
+                                                        GLuint id) {
   MakeFunctionUnique("glBeginQuery");
   interface_->BeginQuery(target, id);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glBeginQueryARB(GLenum target, GLuint id) {
+void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryARB(GLenum target,
+                                                           GLuint id) {
   MakeFunctionUnique("glBeginQueryARB");
   interface_->BeginQuery(target, id);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glBeginQueryEXT(GLenum target, GLuint id) {
+void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryEXT(GLenum target,
+                                                           GLuint id) {
   MakeFunctionUnique("glBeginQueryEXT");
   interface_->BeginQuery(target, id);
 }
@@ -64,8 +70,8 @@ MockGLInterface::Mock_glBindAttribLocation(GLuint program,
   interface_->BindAttribLocation(program, index, name);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glBindBuffer(GLenum target, GLuint buffer) {
+void GL_BINDING_CALL MockGLInterface::Mock_glBindBuffer(GLenum target,
+                                                        GLuint buffer) {
   MakeFunctionUnique("glBindBuffer");
   interface_->BindBuffer(target, buffer);
 }
@@ -128,14 +134,14 @@ MockGLInterface::Mock_glBindRenderbufferEXT(GLenum target,
   interface_->BindRenderbufferEXT(target, renderbuffer);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glBindSampler(GLuint unit, GLuint sampler) {
+void GL_BINDING_CALL MockGLInterface::Mock_glBindSampler(GLuint unit,
+                                                         GLuint sampler) {
   MakeFunctionUnique("glBindSampler");
   interface_->BindSampler(unit, sampler);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glBindTexture(GLenum target, GLuint texture) {
+void GL_BINDING_CALL MockGLInterface::Mock_glBindTexture(GLenum target,
+                                                         GLuint texture) {
   MakeFunctionUnique("glBindTexture");
   interface_->BindTexture(target, texture);
 }
@@ -192,8 +198,8 @@ MockGLInterface::Mock_glBlendEquationSeparate(GLenum modeRGB,
   interface_->BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glBlendFunc(GLenum sfactor, GLenum dfactor) {
+void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunc(GLenum sfactor,
+                                                       GLenum dfactor) {
   MakeFunctionUnique("glBlendFunc");
   interface_->BlendFunc(sfactor, dfactor);
 }
@@ -475,6 +481,18 @@ void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage3D(GLenum target,
                                 width, height);
 }
 
+void GL_BINDING_CALL MockGLInterface::Mock_glCoverFillPathNV(GLuint path,
+                                                             GLenum coverMode) {
+  MakeFunctionUnique("glCoverFillPathNV");
+  interface_->CoverFillPathNV(path, coverMode);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glCoverStrokePathNV(GLuint name, GLenum coverMode) {
+  MakeFunctionUnique("glCoverStrokePathNV");
+  interface_->CoverStrokePathNV(name, coverMode);
+}
+
 GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateProgram(void) {
   MakeFunctionUnique("glCreateProgram");
   return interface_->CreateProgram();
@@ -522,13 +540,19 @@ MockGLInterface::Mock_glDeleteFramebuffersEXT(GLsizei n,
   interface_->DeleteFramebuffersEXT(n, framebuffers);
 }
 
+void GL_BINDING_CALL MockGLInterface::Mock_glDeletePathsNV(GLuint path,
+                                                           GLsizei range) {
+  MakeFunctionUnique("glDeletePathsNV");
+  interface_->DeletePathsNV(path, range);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteProgram(GLuint program) {
   MakeFunctionUnique("glDeleteProgram");
   interface_->DeleteProgram(program);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glDeleteQueries(GLsizei n, const GLuint* ids) {
+void GL_BINDING_CALL MockGLInterface::Mock_glDeleteQueries(GLsizei n,
+                                                           const GLuint* ids) {
   MakeFunctionUnique("glDeleteQueries");
   interface_->DeleteQueries(n, ids);
 }
@@ -616,20 +640,20 @@ void GL_BINDING_CALL MockGLInterface::Mock_glDepthMask(GLboolean flag) {
   interface_->DepthMask(flag);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glDepthRange(GLclampd zNear, GLclampd zFar) {
+void GL_BINDING_CALL MockGLInterface::Mock_glDepthRange(GLclampd zNear,
+                                                        GLclampd zFar) {
   MakeFunctionUnique("glDepthRange");
   interface_->DepthRange(zNear, zFar);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glDepthRangef(GLclampf zNear, GLclampf zFar) {
+void GL_BINDING_CALL MockGLInterface::Mock_glDepthRangef(GLclampf zNear,
+                                                         GLclampf zFar) {
   MakeFunctionUnique("glDepthRangef");
   interface_->DepthRangef(zNear, zFar);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glDetachShader(GLuint program, GLuint shader) {
+void GL_BINDING_CALL MockGLInterface::Mock_glDetachShader(GLuint program,
+                                                          GLuint shader) {
   MakeFunctionUnique("glDetachShader");
   interface_->DetachShader(program, shader);
 }
@@ -653,8 +677,9 @@ MockGLInterface::Mock_glDiscardFramebufferEXT(GLenum target,
   interface_->DiscardFramebufferEXT(target, numAttachments, attachments);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
+void GL_BINDING_CALL MockGLInterface::Mock_glDrawArrays(GLenum mode,
+                                                        GLint first,
+                                                        GLsizei count) {
   MakeFunctionUnique("glDrawArrays");
   interface_->DrawArrays(mode, first, count);
 }
@@ -691,8 +716,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffer(GLenum mode) {
   interface_->DrawBuffer(mode);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glDrawBuffers(GLsizei n, const GLenum* bufs) {
+void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffers(GLsizei n,
+                                                         const GLenum* bufs) {
   MakeFunctionUnique("glDrawBuffers");
   interface_->DrawBuffersARB(n, bufs);
 }
@@ -804,8 +829,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glEndTransformFeedback(void) {
   interface_->EndTransformFeedback();
 }
 
-GLsync GL_BINDING_CALL
-MockGLInterface::Mock_glFenceSync(GLenum condition, GLbitfield flags) {
+GLsync GL_BINDING_CALL MockGLInterface::Mock_glFenceSync(GLenum condition,
+                                                         GLbitfield flags) {
   MakeFunctionUnique("glFenceSync");
   return interface_->FenceSync(condition, flags);
 }
@@ -920,20 +945,20 @@ void GL_BINDING_CALL MockGLInterface::Mock_glFrontFace(GLenum mode) {
   interface_->FrontFace(mode);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenBuffers(GLsizei n, GLuint* buffers) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGenBuffers(GLsizei n,
+                                                        GLuint* buffers) {
   MakeFunctionUnique("glGenBuffers");
   interface_->GenBuffersARB(n, buffers);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenFencesAPPLE(GLsizei n, GLuint* fences) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesAPPLE(GLsizei n,
+                                                            GLuint* fences) {
   MakeFunctionUnique("glGenFencesAPPLE");
   interface_->GenFencesAPPLE(n, fences);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenFencesNV(GLsizei n, GLuint* fences) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesNV(GLsizei n,
+                                                         GLuint* fences) {
   MakeFunctionUnique("glGenFencesNV");
   interface_->GenFencesNV(n, fences);
 }
@@ -950,20 +975,25 @@ MockGLInterface::Mock_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) {
   interface_->GenFramebuffersEXT(n, framebuffers);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenQueries(GLsizei n, GLuint* ids) {
+GLuint GL_BINDING_CALL MockGLInterface::Mock_glGenPathsNV(GLsizei range) {
+  MakeFunctionUnique("glGenPathsNV");
+  return interface_->GenPathsNV(range);
+}
+
+void GL_BINDING_CALL MockGLInterface::Mock_glGenQueries(GLsizei n,
+                                                        GLuint* ids) {
   MakeFunctionUnique("glGenQueries");
   interface_->GenQueries(n, ids);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenQueriesARB(GLsizei n, GLuint* ids) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesARB(GLsizei n,
+                                                           GLuint* ids) {
   MakeFunctionUnique("glGenQueriesARB");
   interface_->GenQueries(n, ids);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenQueriesEXT(GLsizei n, GLuint* ids) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesEXT(GLsizei n,
+                                                           GLuint* ids) {
   MakeFunctionUnique("glGenQueriesEXT");
   interface_->GenQueries(n, ids);
 }
@@ -980,14 +1010,14 @@ MockGLInterface::Mock_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers) {
   interface_->GenRenderbuffersEXT(n, renderbuffers);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenSamplers(GLsizei n, GLuint* samplers) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGenSamplers(GLsizei n,
+                                                         GLuint* samplers) {
   MakeFunctionUnique("glGenSamplers");
   interface_->GenSamplers(n, samplers);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenTextures(GLsizei n, GLuint* textures) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGenTextures(GLsizei n,
+                                                         GLuint* textures) {
   MakeFunctionUnique("glGenTextures");
   interface_->GenTextures(n, textures);
 }
@@ -998,8 +1028,8 @@ MockGLInterface::Mock_glGenTransformFeedbacks(GLsizei n, GLuint* ids) {
   interface_->GenTransformFeedbacks(n, ids);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGenVertexArrays(GLsizei n, GLuint* arrays) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGenVertexArrays(GLsizei n,
+                                                             GLuint* arrays) {
   MakeFunctionUnique("glGenVertexArrays");
   interface_->GenVertexArraysOES(n, arrays);
 }
@@ -1097,8 +1127,8 @@ MockGLInterface::Mock_glGetAttribLocation(GLuint program, const char* name) {
   return interface_->GetAttribLocation(program, name);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGetBooleanv(GLenum pname, GLboolean* params) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGetBooleanv(GLenum pname,
+                                                         GLboolean* params) {
   MakeFunctionUnique("glGetBooleanv");
   interface_->GetBooleanv(pname, params);
 }
@@ -1123,8 +1153,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glGetFenceivNV(GLuint fence,
   interface_->GetFenceivNV(fence, pname, params);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGetFloatv(GLenum pname, GLfloat* params) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGetFloatv(GLenum pname,
+                                                       GLfloat* params) {
   MakeFunctionUnique("glGetFloatv");
   interface_->GetFloatv(pname, params);
 }
@@ -1183,8 +1213,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64i_v(GLenum target,
   interface_->GetInteger64i_v(target, index, data);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGetInteger64v(GLenum pname, GLint64* params) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64v(GLenum pname,
+                                                           GLint64* params) {
   MakeFunctionUnique("glGetInteger64v");
   interface_->GetInteger64v(pname, params);
 }
@@ -1196,8 +1226,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegeri_v(GLenum target,
   interface_->GetIntegeri_v(target, index, data);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGetIntegerv(GLenum pname, GLint* params) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegerv(GLenum pname,
+                                                         GLint* params) {
   MakeFunctionUnique("glGetIntegerv");
   interface_->GetIntegerv(pname, params);
 }
@@ -1335,8 +1365,9 @@ MockGLInterface::Mock_glGetQueryObjectuivEXT(GLuint id,
   interface_->GetQueryObjectuiv(id, pname, params);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glGetQueryiv(GLenum target, GLenum pname, GLint* params) {
+void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryiv(GLenum target,
+                                                        GLenum pname,
+                                                        GLint* params) {
   MakeFunctionUnique("glGetQueryiv");
   interface_->GetQueryiv(target, pname, params);
 }
@@ -1627,6 +1658,11 @@ MockGLInterface::Mock_glIsFramebufferEXT(GLuint framebuffer) {
   return interface_->IsFramebufferEXT(framebuffer);
 }
 
+GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsPathNV(GLuint path) {
+  MakeFunctionUnique("glIsPathNV");
+  return interface_->IsPathNV(path);
+}
+
 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsProgram(GLuint program) {
   MakeFunctionUnique("glIsProgram");
   return interface_->IsProgram(program);
@@ -1712,14 +1748,14 @@ void GL_BINDING_CALL MockGLInterface::Mock_glLinkProgram(GLuint program) {
   interface_->LinkProgram(program);
 }
 
-void* GL_BINDING_CALL
-MockGLInterface::Mock_glMapBuffer(GLenum target, GLenum access) {
+void* GL_BINDING_CALL MockGLInterface::Mock_glMapBuffer(GLenum target,
+                                                        GLenum access) {
   MakeFunctionUnique("glMapBuffer");
   return interface_->MapBuffer(target, access);
 }
 
-void* GL_BINDING_CALL
-MockGLInterface::Mock_glMapBufferOES(GLenum target, GLenum access) {
+void* GL_BINDING_CALL MockGLInterface::Mock_glMapBufferOES(GLenum target,
+                                                           GLenum access) {
   MakeFunctionUnique("glMapBufferOES");
   return interface_->MapBuffer(target, access);
 }
@@ -1748,31 +1784,64 @@ MockGLInterface::Mock_glMatrixLoadIdentityEXT(GLenum matrixMode) {
   interface_->MatrixLoadIdentityEXT(matrixMode);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glMatrixLoadfEXT(GLenum matrixMode, const GLfloat* m) {
+void GL_BINDING_CALL MockGLInterface::Mock_glMatrixLoadfEXT(GLenum matrixMode,
+                                                            const GLfloat* m) {
   MakeFunctionUnique("glMatrixLoadfEXT");
   interface_->MatrixLoadfEXT(matrixMode, m);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glPathCommandsNV(GLuint path,
+                                       GLsizei numCommands,
+                                       const GLubyte* commands,
+                                       GLsizei numCoords,
+                                       GLenum coordType,
+                                       const GLvoid* coords) {
+  MakeFunctionUnique("glPathCommandsNV");
+  interface_->PathCommandsNV(path, numCommands, commands, numCoords, coordType,
+                             coords);
+}
+
+void GL_BINDING_CALL MockGLInterface::Mock_glPathParameterfNV(GLuint path,
+                                                              GLenum pname,
+                                                              GLfloat value) {
+  MakeFunctionUnique("glPathParameterfNV");
+  interface_->PathParameterfNV(path, pname, value);
+}
+
+void GL_BINDING_CALL MockGLInterface::Mock_glPathParameteriNV(GLuint path,
+                                                              GLenum pname,
+                                                              GLint value) {
+  MakeFunctionUnique("glPathParameteriNV");
+  interface_->PathParameteriNV(path, pname, value);
+}
+
+void GL_BINDING_CALL MockGLInterface::Mock_glPathStencilFuncNV(GLenum func,
+                                                               GLint ref,
+                                                               GLuint mask) {
+  MakeFunctionUnique("glPathStencilFuncNV");
+  interface_->PathStencilFuncNV(func, ref, mask);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glPauseTransformFeedback(void) {
   MakeFunctionUnique("glPauseTransformFeedback");
   interface_->PauseTransformFeedback();
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glPixelStorei(GLenum pname, GLint param) {
+void GL_BINDING_CALL MockGLInterface::Mock_glPixelStorei(GLenum pname,
+                                                         GLint param) {
   MakeFunctionUnique("glPixelStorei");
   interface_->PixelStorei(pname, param);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glPointParameteri(GLenum pname, GLint param) {
+void GL_BINDING_CALL MockGLInterface::Mock_glPointParameteri(GLenum pname,
+                                                             GLint param) {
   MakeFunctionUnique("glPointParameteri");
   interface_->PointParameteri(pname, param);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glPolygonOffset(GLfloat factor, GLfloat units) {
+void GL_BINDING_CALL MockGLInterface::Mock_glPolygonOffset(GLfloat factor,
+                                                           GLfloat units) {
   MakeFunctionUnique("glPolygonOffset");
   interface_->PolygonOffset(factor, units);
 }
@@ -1812,14 +1881,14 @@ MockGLInterface::Mock_glPushGroupMarkerEXT(GLsizei length, const char* marker) {
   interface_->PushGroupMarkerEXT(length, marker);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glQueryCounter(GLuint id, GLenum target) {
+void GL_BINDING_CALL MockGLInterface::Mock_glQueryCounter(GLuint id,
+                                                          GLenum target) {
   MakeFunctionUnique("glQueryCounter");
   interface_->QueryCounter(id, target);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glQueryCounterEXT(GLuint id, GLenum target) {
+void GL_BINDING_CALL MockGLInterface::Mock_glQueryCounterEXT(GLuint id,
+                                                             GLenum target) {
   MakeFunctionUnique("glQueryCounterEXT");
   interface_->QueryCounter(id, target);
 }
@@ -1913,8 +1982,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glResumeTransformFeedback(void) {
   interface_->ResumeTransformFeedback();
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glSampleCoverage(GLclampf value, GLboolean invert) {
+void GL_BINDING_CALL MockGLInterface::Mock_glSampleCoverage(GLclampf value,
+                                                            GLboolean invert) {
   MakeFunctionUnique("glSampleCoverage");
   interface_->SampleCoverage(value, invert);
 }
@@ -1962,8 +2031,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceAPPLE(GLuint fence) {
   interface_->SetFenceAPPLE(fence);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glSetFenceNV(GLuint fence, GLenum condition) {
+void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceNV(GLuint fence,
+                                                        GLenum condition) {
   MakeFunctionUnique("glSetFenceNV");
   interface_->SetFenceNV(fence, condition);
 }
@@ -1986,8 +2055,16 @@ MockGLInterface::Mock_glShaderSource(GLuint shader,
   interface_->ShaderSource(shader, count, str, length);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glStencilFunc(GLenum func, GLint ref, GLuint mask) {
+void GL_BINDING_CALL MockGLInterface::Mock_glStencilFillPathNV(GLuint path,
+                                                               GLenum fillMode,
+                                                               GLuint mask) {
+  MakeFunctionUnique("glStencilFillPathNV");
+  interface_->StencilFillPathNV(path, fillMode, mask);
+}
+
+void GL_BINDING_CALL MockGLInterface::Mock_glStencilFunc(GLenum func,
+                                                         GLint ref,
+                                                         GLuint mask) {
   MakeFunctionUnique("glStencilFunc");
   interface_->StencilFunc(func, ref, mask);
 }
@@ -2005,14 +2082,15 @@ void GL_BINDING_CALL MockGLInterface::Mock_glStencilMask(GLuint mask) {
   interface_->StencilMask(mask);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glStencilMaskSeparate(GLenum face, GLuint mask) {
+void GL_BINDING_CALL MockGLInterface::Mock_glStencilMaskSeparate(GLenum face,
+                                                                 GLuint mask) {
   MakeFunctionUnique("glStencilMaskSeparate");
   interface_->StencilMaskSeparate(face, mask);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
+void GL_BINDING_CALL MockGLInterface::Mock_glStencilOp(GLenum fail,
+                                                       GLenum zfail,
+                                                       GLenum zpass) {
   MakeFunctionUnique("glStencilOp");
   interface_->StencilOp(fail, zfail, zpass);
 }
@@ -2025,6 +2103,32 @@ void GL_BINDING_CALL MockGLInterface::Mock_glStencilOpSeparate(GLenum face,
   interface_->StencilOpSeparate(face, fail, zfail, zpass);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glStencilStrokePathNV(GLuint path,
+                                            GLint reference,
+                                            GLuint mask) {
+  MakeFunctionUnique("glStencilStrokePathNV");
+  interface_->StencilStrokePathNV(path, reference, mask);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glStencilThenCoverFillPathNV(GLuint path,
+                                                   GLenum fillMode,
+                                                   GLuint mask,
+                                                   GLenum coverMode) {
+  MakeFunctionUnique("glStencilThenCoverFillPathNV");
+  interface_->StencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glStencilThenCoverStrokePathNV(GLuint path,
+                                                     GLint reference,
+                                                     GLuint mask,
+                                                     GLenum coverMode) {
+  MakeFunctionUnique("glStencilThenCoverStrokePathNV");
+  interface_->StencilThenCoverStrokePathNV(path, reference, mask, coverMode);
+}
+
 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glTestFenceAPPLE(GLuint fence) {
   MakeFunctionUnique("glTestFenceAPPLE");
   return interface_->TestFenceAPPLE(fence);
@@ -2163,8 +2267,8 @@ MockGLInterface::Mock_glTransformFeedbackVaryings(GLuint program,
   interface_->TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glUniform1f(GLint location, GLfloat x) {
+void GL_BINDING_CALL MockGLInterface::Mock_glUniform1f(GLint location,
+                                                       GLfloat x) {
   MakeFunctionUnique("glUniform1f");
   interface_->Uniform1f(location, x);
 }
@@ -2176,8 +2280,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform1fv(GLint location,
   interface_->Uniform1fv(location, count, v);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glUniform1i(GLint location, GLint x) {
+void GL_BINDING_CALL MockGLInterface::Mock_glUniform1i(GLint location,
+                                                       GLint x) {
   MakeFunctionUnique("glUniform1i");
   interface_->Uniform1i(location, x);
 }
@@ -2189,8 +2293,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform1iv(GLint location,
   interface_->Uniform1iv(location, count, v);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glUniform1ui(GLint location, GLuint v0) {
+void GL_BINDING_CALL MockGLInterface::Mock_glUniform1ui(GLint location,
+                                                        GLuint v0) {
   MakeFunctionUnique("glUniform1ui");
   interface_->Uniform1ui(location, v0);
 }
@@ -2202,8 +2306,9 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform1uiv(GLint location,
   interface_->Uniform1uiv(location, count, v);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glUniform2f(GLint location, GLfloat x, GLfloat y) {
+void GL_BINDING_CALL MockGLInterface::Mock_glUniform2f(GLint location,
+                                                       GLfloat x,
+                                                       GLfloat y) {
   MakeFunctionUnique("glUniform2f");
   interface_->Uniform2f(location, x, y);
 }
@@ -2215,8 +2320,9 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform2fv(GLint location,
   interface_->Uniform2fv(location, count, v);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glUniform2i(GLint location, GLint x, GLint y) {
+void GL_BINDING_CALL MockGLInterface::Mock_glUniform2i(GLint location,
+                                                       GLint x,
+                                                       GLint y) {
   MakeFunctionUnique("glUniform2i");
   interface_->Uniform2i(location, x, y);
 }
@@ -2228,8 +2334,9 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform2iv(GLint location,
   interface_->Uniform2iv(location, count, v);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glUniform2ui(GLint location, GLuint v0, GLuint v1) {
+void GL_BINDING_CALL MockGLInterface::Mock_glUniform2ui(GLint location,
+                                                        GLuint v0,
+                                                        GLuint v1) {
   MakeFunctionUnique("glUniform2ui");
   interface_->Uniform2ui(location, v0, v1);
 }
@@ -2256,8 +2363,10 @@ void GL_BINDING_CALL MockGLInterface::Mock_glUniform3fv(GLint location,
   interface_->Uniform3fv(location, count, v);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glUniform3i(GLint location, GLint x, GLint y, GLint z) {
+void GL_BINDING_CALL MockGLInterface::Mock_glUniform3i(GLint location,
+                                                       GLint x,
+                                                       GLint y,
+                                                       GLint z) {
   MakeFunctionUnique("glUniform3i");
   interface_->Uniform3i(location, x, y, z);
 }
@@ -2443,8 +2552,8 @@ void GL_BINDING_CALL MockGLInterface::Mock_glValidateProgram(GLuint program) {
   interface_->ValidateProgram(program);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glVertexAttrib1f(GLuint indx, GLfloat x) {
+void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib1f(GLuint indx,
+                                                            GLfloat x) {
   MakeFunctionUnique("glVertexAttrib1f");
   interface_->VertexAttrib1f(indx, x);
 }
@@ -2455,8 +2564,9 @@ MockGLInterface::Mock_glVertexAttrib1fv(GLuint indx, const GLfloat* values) {
   interface_->VertexAttrib1fv(indx, values);
 }
 
-void GL_BINDING_CALL
-MockGLInterface::Mock_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
+void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib2f(GLuint indx,
+                                                            GLfloat x,
+                                                            GLfloat y) {
   MakeFunctionUnique("glVertexAttrib2f");
   interface_->VertexAttrib2f(indx, x, y);
 }
@@ -2587,6 +2697,8 @@ static void MockInvalidFunction() {
 void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
   if (strcmp(name, "glActiveTexture") == 0)
     return reinterpret_cast<void*>(Mock_glActiveTexture);
+  if (strcmp(name, "glApplyFramebufferAttachmentCMAAINTEL") == 0)
+    return reinterpret_cast<void*>(Mock_glApplyFramebufferAttachmentCMAAINTEL);
   if (strcmp(name, "glAttachShader") == 0)
     return reinterpret_cast<void*>(Mock_glAttachShader);
   if (strcmp(name, "glBeginQuery") == 0)
@@ -2697,6 +2809,10 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
     return reinterpret_cast<void*>(Mock_glCopyTexSubImage2D);
   if (strcmp(name, "glCopyTexSubImage3D") == 0)
     return reinterpret_cast<void*>(Mock_glCopyTexSubImage3D);
+  if (strcmp(name, "glCoverFillPathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glCoverFillPathNV);
+  if (strcmp(name, "glCoverStrokePathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glCoverStrokePathNV);
   if (strcmp(name, "glCreateProgram") == 0)
     return reinterpret_cast<void*>(Mock_glCreateProgram);
   if (strcmp(name, "glCreateShader") == 0)
@@ -2713,6 +2829,8 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
     return reinterpret_cast<void*>(Mock_glDeleteFramebuffers);
   if (strcmp(name, "glDeleteFramebuffersEXT") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteFramebuffersEXT);
+  if (strcmp(name, "glDeletePathsNV") == 0)
+    return reinterpret_cast<void*>(Mock_glDeletePathsNV);
   if (strcmp(name, "glDeleteProgram") == 0)
     return reinterpret_cast<void*>(Mock_glDeleteProgram);
   if (strcmp(name, "glDeleteQueries") == 0)
@@ -2837,6 +2955,8 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
     return reinterpret_cast<void*>(Mock_glGenFramebuffers);
   if (strcmp(name, "glGenFramebuffersEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGenFramebuffersEXT);
+  if (strcmp(name, "glGenPathsNV") == 0)
+    return reinterpret_cast<void*>(Mock_glGenPathsNV);
   if (strcmp(name, "glGenQueries") == 0)
     return reinterpret_cast<void*>(Mock_glGenQueries);
   if (strcmp(name, "glGenQueriesARB") == 0)
@@ -3020,6 +3140,8 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
     return reinterpret_cast<void*>(Mock_glIsFramebuffer);
   if (strcmp(name, "glIsFramebufferEXT") == 0)
     return reinterpret_cast<void*>(Mock_glIsFramebufferEXT);
+  if (strcmp(name, "glIsPathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glIsPathNV);
   if (strcmp(name, "glIsProgram") == 0)
     return reinterpret_cast<void*>(Mock_glIsProgram);
   if (strcmp(name, "glIsQuery") == 0)
@@ -3064,6 +3186,14 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
     return reinterpret_cast<void*>(Mock_glMatrixLoadIdentityEXT);
   if (strcmp(name, "glMatrixLoadfEXT") == 0)
     return reinterpret_cast<void*>(Mock_glMatrixLoadfEXT);
+  if (strcmp(name, "glPathCommandsNV") == 0)
+    return reinterpret_cast<void*>(Mock_glPathCommandsNV);
+  if (strcmp(name, "glPathParameterfNV") == 0)
+    return reinterpret_cast<void*>(Mock_glPathParameterfNV);
+  if (strcmp(name, "glPathParameteriNV") == 0)
+    return reinterpret_cast<void*>(Mock_glPathParameteriNV);
+  if (strcmp(name, "glPathStencilFuncNV") == 0)
+    return reinterpret_cast<void*>(Mock_glPathStencilFuncNV);
   if (strcmp(name, "glPauseTransformFeedback") == 0)
     return reinterpret_cast<void*>(Mock_glPauseTransformFeedback);
   if (strcmp(name, "glPixelStorei") == 0)
@@ -3126,6 +3256,8 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
     return reinterpret_cast<void*>(Mock_glShaderBinary);
   if (strcmp(name, "glShaderSource") == 0)
     return reinterpret_cast<void*>(Mock_glShaderSource);
+  if (strcmp(name, "glStencilFillPathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilFillPathNV);
   if (strcmp(name, "glStencilFunc") == 0)
     return reinterpret_cast<void*>(Mock_glStencilFunc);
   if (strcmp(name, "glStencilFuncSeparate") == 0)
@@ -3138,6 +3270,12 @@ void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
     return reinterpret_cast<void*>(Mock_glStencilOp);
   if (strcmp(name, "glStencilOpSeparate") == 0)
     return reinterpret_cast<void*>(Mock_glStencilOpSeparate);
+  if (strcmp(name, "glStencilStrokePathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilStrokePathNV);
+  if (strcmp(name, "glStencilThenCoverFillPathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilThenCoverFillPathNV);
+  if (strcmp(name, "glStencilThenCoverStrokePathNV") == 0)
+    return reinterpret_cast<void*>(Mock_glStencilThenCoverStrokePathNV);
   if (strcmp(name, "glTestFenceAPPLE") == 0)
     return reinterpret_cast<void*>(Mock_glTestFenceAPPLE);
   if (strcmp(name, "glTestFenceNV") == 0)
diff --git a/chromium/ui/gl/gl_bindings_autogen_mock.h b/chromium/ui/gl/gl_bindings_autogen_mock.h
index 9dc82a05004..c0f00910ca9 100644
--- a/chromium/ui/gl/gl_bindings_autogen_mock.h
+++ b/chromium/ui/gl/gl_bindings_autogen_mock.h
@@ -9,16 +9,19 @@
 // DO NOT EDIT!
 
 static void GL_BINDING_CALL Mock_glActiveTexture(GLenum texture);
+static void GL_BINDING_CALL Mock_glApplyFramebufferAttachmentCMAAINTEL(void);
 static void GL_BINDING_CALL Mock_glAttachShader(GLuint program, GLuint shader);
 static void GL_BINDING_CALL Mock_glBeginQuery(GLenum target, GLuint id);
 static void GL_BINDING_CALL Mock_glBeginQueryARB(GLenum target, GLuint id);
 static void GL_BINDING_CALL Mock_glBeginQueryEXT(GLenum target, GLuint id);
 static void GL_BINDING_CALL Mock_glBeginTransformFeedback(GLenum primitiveMode);
-static void GL_BINDING_CALL
-Mock_glBindAttribLocation(GLuint program, GLuint index, const char* name);
+static void GL_BINDING_CALL Mock_glBindAttribLocation(GLuint program,
+                                                      GLuint index,
+                                                      const char* name);
 static void GL_BINDING_CALL Mock_glBindBuffer(GLenum target, GLuint buffer);
-static void GL_BINDING_CALL
-Mock_glBindBufferBase(GLenum target, GLuint index, GLuint buffer);
+static void GL_BINDING_CALL Mock_glBindBufferBase(GLenum target,
+                                                  GLuint index,
+                                                  GLuint buffer);
 static void GL_BINDING_CALL Mock_glBindBufferRange(GLenum target,
                                                    GLuint index,
                                                    GLuint buffer,
@@ -32,28 +35,30 @@ Mock_glBindFragDataLocationIndexed(GLuint program,
                                    GLuint colorNumber,
                                    GLuint index,
                                    const char* name);
-static void GL_BINDING_CALL
-Mock_glBindFramebuffer(GLenum target, GLuint framebuffer);
-static void GL_BINDING_CALL
-Mock_glBindFramebufferEXT(GLenum target, GLuint framebuffer);
-static void GL_BINDING_CALL
-Mock_glBindRenderbuffer(GLenum target, GLuint renderbuffer);
-static void GL_BINDING_CALL
-Mock_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer);
+static void GL_BINDING_CALL Mock_glBindFramebuffer(GLenum target,
+                                                   GLuint framebuffer);
+static void GL_BINDING_CALL Mock_glBindFramebufferEXT(GLenum target,
+                                                      GLuint framebuffer);
+static void GL_BINDING_CALL Mock_glBindRenderbuffer(GLenum target,
+                                                    GLuint renderbuffer);
+static void GL_BINDING_CALL Mock_glBindRenderbufferEXT(GLenum target,
+                                                       GLuint renderbuffer);
 static void GL_BINDING_CALL Mock_glBindSampler(GLuint unit, GLuint sampler);
 static void GL_BINDING_CALL Mock_glBindTexture(GLenum target, GLuint texture);
-static void GL_BINDING_CALL
-Mock_glBindTransformFeedback(GLenum target, GLuint id);
+static void GL_BINDING_CALL Mock_glBindTransformFeedback(GLenum target,
+                                                         GLuint id);
 static void GL_BINDING_CALL Mock_glBindVertexArray(GLuint array);
 static void GL_BINDING_CALL Mock_glBindVertexArrayAPPLE(GLuint array);
 static void GL_BINDING_CALL Mock_glBindVertexArrayOES(GLuint array);
 static void GL_BINDING_CALL Mock_glBlendBarrierKHR(void);
 static void GL_BINDING_CALL Mock_glBlendBarrierNV(void);
-static void GL_BINDING_CALL
-Mock_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+static void GL_BINDING_CALL Mock_glBlendColor(GLclampf red,
+                                              GLclampf green,
+                                              GLclampf blue,
+                                              GLclampf alpha);
 static void GL_BINDING_CALL Mock_glBlendEquation(GLenum mode);
-static void GL_BINDING_CALL
-Mock_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
+static void GL_BINDING_CALL Mock_glBlendEquationSeparate(GLenum modeRGB,
+                                                         GLenum modeAlpha);
 static void GL_BINDING_CALL Mock_glBlendFunc(GLenum sfactor, GLenum dfactor);
 static void GL_BINDING_CALL Mock_glBlendFuncSeparate(GLenum srcRGB,
                                                      GLenum dstRGB,
@@ -104,19 +109,25 @@ static void GL_BINDING_CALL Mock_glClearBufferfi(GLenum buffer,
                                                  GLint drawbuffer,
                                                  const GLfloat depth,
                                                  GLint stencil);
-static void GL_BINDING_CALL
-Mock_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value);
-static void GL_BINDING_CALL
-Mock_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value);
-static void GL_BINDING_CALL
-Mock_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value);
-static void GL_BINDING_CALL
-Mock_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+static void GL_BINDING_CALL Mock_glClearBufferfv(GLenum buffer,
+                                                 GLint drawbuffer,
+                                                 const GLfloat* value);
+static void GL_BINDING_CALL Mock_glClearBufferiv(GLenum buffer,
+                                                 GLint drawbuffer,
+                                                 const GLint* value);
+static void GL_BINDING_CALL Mock_glClearBufferuiv(GLenum buffer,
+                                                  GLint drawbuffer,
+                                                  const GLuint* value);
+static void GL_BINDING_CALL Mock_glClearColor(GLclampf red,
+                                              GLclampf green,
+                                              GLclampf blue,
+                                              GLclampf alpha);
 static void GL_BINDING_CALL Mock_glClearDepth(GLclampd depth);
 static void GL_BINDING_CALL Mock_glClearDepthf(GLclampf depth);
 static void GL_BINDING_CALL Mock_glClearStencil(GLint s);
-static GLenum GL_BINDING_CALL
-Mock_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+static GLenum GL_BINDING_CALL Mock_glClientWaitSync(GLsync sync,
+                                                    GLbitfield flags,
+                                                    GLuint64 timeout);
 static void GL_BINDING_CALL Mock_glColorMask(GLboolean red,
                                              GLboolean green,
                                              GLboolean blue,
@@ -189,43 +200,48 @@ static void GL_BINDING_CALL Mock_glCopyTexSubImage3D(GLenum target,
                                                      GLint y,
                                                      GLsizei width,
                                                      GLsizei height);
+static void GL_BINDING_CALL Mock_glCoverFillPathNV(GLuint path,
+                                                   GLenum coverMode);
+static void GL_BINDING_CALL Mock_glCoverStrokePathNV(GLuint name,
+                                                     GLenum coverMode);
 static GLuint GL_BINDING_CALL Mock_glCreateProgram(void);
 static GLuint GL_BINDING_CALL Mock_glCreateShader(GLenum type);
 static void GL_BINDING_CALL Mock_glCullFace(GLenum mode);
-static void GL_BINDING_CALL
-Mock_glDeleteBuffers(GLsizei n, const GLuint* buffers);
-static void GL_BINDING_CALL
-Mock_glDeleteFencesAPPLE(GLsizei n, const GLuint* fences);
-static void GL_BINDING_CALL
-Mock_glDeleteFencesNV(GLsizei n, const GLuint* fences);
+static void GL_BINDING_CALL Mock_glDeleteBuffers(GLsizei n,
+                                                 const GLuint* buffers);
+static void GL_BINDING_CALL Mock_glDeleteFencesAPPLE(GLsizei n,
+                                                     const GLuint* fences);
+static void GL_BINDING_CALL Mock_glDeleteFencesNV(GLsizei n,
+                                                  const GLuint* fences);
 static void GL_BINDING_CALL
 Mock_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers);
 static void GL_BINDING_CALL
 Mock_glDeleteFramebuffersEXT(GLsizei n, const GLuint* framebuffers);
+static void GL_BINDING_CALL Mock_glDeletePathsNV(GLuint path, GLsizei range);
 static void GL_BINDING_CALL Mock_glDeleteProgram(GLuint program);
 static void GL_BINDING_CALL Mock_glDeleteQueries(GLsizei n, const GLuint* ids);
-static void GL_BINDING_CALL
-Mock_glDeleteQueriesARB(GLsizei n, const GLuint* ids);
-static void GL_BINDING_CALL
-Mock_glDeleteQueriesEXT(GLsizei n, const GLuint* ids);
+static void GL_BINDING_CALL Mock_glDeleteQueriesARB(GLsizei n,
+                                                    const GLuint* ids);
+static void GL_BINDING_CALL Mock_glDeleteQueriesEXT(GLsizei n,
+                                                    const GLuint* ids);
 static void GL_BINDING_CALL
 Mock_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
 static void GL_BINDING_CALL
 Mock_glDeleteRenderbuffersEXT(GLsizei n, const GLuint* renderbuffers);
-static void GL_BINDING_CALL
-Mock_glDeleteSamplers(GLsizei n, const GLuint* samplers);
+static void GL_BINDING_CALL Mock_glDeleteSamplers(GLsizei n,
+                                                  const GLuint* samplers);
 static void GL_BINDING_CALL Mock_glDeleteShader(GLuint shader);
 static void GL_BINDING_CALL Mock_glDeleteSync(GLsync sync);
-static void GL_BINDING_CALL
-Mock_glDeleteTextures(GLsizei n, const GLuint* textures);
-static void GL_BINDING_CALL
-Mock_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids);
-static void GL_BINDING_CALL
-Mock_glDeleteVertexArrays(GLsizei n, const GLuint* arrays);
+static void GL_BINDING_CALL Mock_glDeleteTextures(GLsizei n,
+                                                  const GLuint* textures);
+static void GL_BINDING_CALL Mock_glDeleteTransformFeedbacks(GLsizei n,
+                                                            const GLuint* ids);
+static void GL_BINDING_CALL Mock_glDeleteVertexArrays(GLsizei n,
+                                                      const GLuint* arrays);
 static void GL_BINDING_CALL
 Mock_glDeleteVertexArraysAPPLE(GLsizei n, const GLuint* arrays);
-static void GL_BINDING_CALL
-Mock_glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays);
+static void GL_BINDING_CALL Mock_glDeleteVertexArraysOES(GLsizei n,
+                                                         const GLuint* arrays);
 static void GL_BINDING_CALL Mock_glDepthFunc(GLenum func);
 static void GL_BINDING_CALL Mock_glDepthMask(GLboolean flag);
 static void GL_BINDING_CALL Mock_glDepthRange(GLclampd zNear, GLclampd zFar);
@@ -237,8 +253,9 @@ static void GL_BINDING_CALL
 Mock_glDiscardFramebufferEXT(GLenum target,
                              GLsizei numAttachments,
                              const GLenum* attachments);
-static void GL_BINDING_CALL
-Mock_glDrawArrays(GLenum mode, GLint first, GLsizei count);
+static void GL_BINDING_CALL Mock_glDrawArrays(GLenum mode,
+                                              GLint first,
+                                              GLsizei count);
 static void GL_BINDING_CALL Mock_glDrawArraysInstanced(GLenum mode,
                                                        GLint first,
                                                        GLsizei count,
@@ -253,10 +270,10 @@ static void GL_BINDING_CALL Mock_glDrawArraysInstancedARB(GLenum mode,
                                                           GLsizei primcount);
 static void GL_BINDING_CALL Mock_glDrawBuffer(GLenum mode);
 static void GL_BINDING_CALL Mock_glDrawBuffers(GLsizei n, const GLenum* bufs);
-static void GL_BINDING_CALL
-Mock_glDrawBuffersARB(GLsizei n, const GLenum* bufs);
-static void GL_BINDING_CALL
-Mock_glDrawBuffersEXT(GLsizei n, const GLenum* bufs);
+static void GL_BINDING_CALL Mock_glDrawBuffersARB(GLsizei n,
+                                                  const GLenum* bufs);
+static void GL_BINDING_CALL Mock_glDrawBuffersEXT(GLsizei n,
+                                                  const GLenum* bufs);
 static void GL_BINDING_CALL Mock_glDrawElements(GLenum mode,
                                                 GLsizei count,
                                                 GLenum type,
@@ -293,8 +310,8 @@ static void GL_BINDING_CALL Mock_glEndQuery(GLenum target);
 static void GL_BINDING_CALL Mock_glEndQueryARB(GLenum target);
 static void GL_BINDING_CALL Mock_glEndQueryEXT(GLenum target);
 static void GL_BINDING_CALL Mock_glEndTransformFeedback(void);
-static GLsync GL_BINDING_CALL
-Mock_glFenceSync(GLenum condition, GLbitfield flags);
+static GLsync GL_BINDING_CALL Mock_glFenceSync(GLenum condition,
+                                               GLbitfield flags);
 static void GL_BINDING_CALL Mock_glFinish(void);
 static void GL_BINDING_CALL Mock_glFinishFenceAPPLE(GLuint fence);
 static void GL_BINDING_CALL Mock_glFinishFenceNV(GLuint fence);
@@ -345,26 +362,27 @@ static void GL_BINDING_CALL Mock_glFrontFace(GLenum mode);
 static void GL_BINDING_CALL Mock_glGenBuffers(GLsizei n, GLuint* buffers);
 static void GL_BINDING_CALL Mock_glGenFencesAPPLE(GLsizei n, GLuint* fences);
 static void GL_BINDING_CALL Mock_glGenFencesNV(GLsizei n, GLuint* fences);
-static void GL_BINDING_CALL
-Mock_glGenFramebuffers(GLsizei n, GLuint* framebuffers);
-static void GL_BINDING_CALL
-Mock_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers);
+static void GL_BINDING_CALL Mock_glGenFramebuffers(GLsizei n,
+                                                   GLuint* framebuffers);
+static void GL_BINDING_CALL Mock_glGenFramebuffersEXT(GLsizei n,
+                                                      GLuint* framebuffers);
+static GLuint GL_BINDING_CALL Mock_glGenPathsNV(GLsizei range);
 static void GL_BINDING_CALL Mock_glGenQueries(GLsizei n, GLuint* ids);
 static void GL_BINDING_CALL Mock_glGenQueriesARB(GLsizei n, GLuint* ids);
 static void GL_BINDING_CALL Mock_glGenQueriesEXT(GLsizei n, GLuint* ids);
-static void GL_BINDING_CALL
-Mock_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers);
-static void GL_BINDING_CALL
-Mock_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers);
+static void GL_BINDING_CALL Mock_glGenRenderbuffers(GLsizei n,
+                                                    GLuint* renderbuffers);
+static void GL_BINDING_CALL Mock_glGenRenderbuffersEXT(GLsizei n,
+                                                       GLuint* renderbuffers);
 static void GL_BINDING_CALL Mock_glGenSamplers(GLsizei n, GLuint* samplers);
 static void GL_BINDING_CALL Mock_glGenTextures(GLsizei n, GLuint* textures);
-static void GL_BINDING_CALL
-Mock_glGenTransformFeedbacks(GLsizei n, GLuint* ids);
+static void GL_BINDING_CALL Mock_glGenTransformFeedbacks(GLsizei n,
+                                                         GLuint* ids);
 static void GL_BINDING_CALL Mock_glGenVertexArrays(GLsizei n, GLuint* arrays);
-static void GL_BINDING_CALL
-Mock_glGenVertexArraysAPPLE(GLsizei n, GLuint* arrays);
-static void GL_BINDING_CALL
-Mock_glGenVertexArraysOES(GLsizei n, GLuint* arrays);
+static void GL_BINDING_CALL Mock_glGenVertexArraysAPPLE(GLsizei n,
+                                                        GLuint* arrays);
+static void GL_BINDING_CALL Mock_glGenVertexArraysOES(GLsizei n,
+                                                      GLuint* arrays);
 static void GL_BINDING_CALL Mock_glGenerateMipmap(GLenum target);
 static void GL_BINDING_CALL Mock_glGenerateMipmapEXT(GLenum target);
 static void GL_BINDING_CALL Mock_glGetActiveAttrib(GLuint program,
@@ -402,17 +420,19 @@ static void GL_BINDING_CALL Mock_glGetAttachedShaders(GLuint program,
                                                       GLsizei maxcount,
                                                       GLsizei* count,
                                                       GLuint* shaders);
-static GLint GL_BINDING_CALL
-Mock_glGetAttribLocation(GLuint program, const char* name);
+static GLint GL_BINDING_CALL Mock_glGetAttribLocation(GLuint program,
+                                                      const char* name);
 static void GL_BINDING_CALL Mock_glGetBooleanv(GLenum pname, GLboolean* params);
-static void GL_BINDING_CALL
-Mock_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
+static void GL_BINDING_CALL Mock_glGetBufferParameteriv(GLenum target,
+                                                        GLenum pname,
+                                                        GLint* params);
 static GLenum GL_BINDING_CALL Mock_glGetError(void);
-static void GL_BINDING_CALL
-Mock_glGetFenceivNV(GLuint fence, GLenum pname, GLint* params);
+static void GL_BINDING_CALL Mock_glGetFenceivNV(GLuint fence,
+                                                GLenum pname,
+                                                GLint* params);
 static void GL_BINDING_CALL Mock_glGetFloatv(GLenum pname, GLfloat* params);
-static GLint GL_BINDING_CALL
-Mock_glGetFragDataLocation(GLuint program, const char* name);
+static GLint GL_BINDING_CALL Mock_glGetFragDataLocation(GLuint program,
+                                                        const char* name);
 static void GL_BINDING_CALL
 Mock_glGetFramebufferAttachmentParameteriv(GLenum target,
                                            GLenum attachment,
@@ -427,11 +447,13 @@ static GLenum GL_BINDING_CALL Mock_glGetGraphicsResetStatus(void);
 static GLenum GL_BINDING_CALL Mock_glGetGraphicsResetStatusARB(void);
 static GLenum GL_BINDING_CALL Mock_glGetGraphicsResetStatusEXT(void);
 static GLenum GL_BINDING_CALL Mock_glGetGraphicsResetStatusKHR(void);
-static void GL_BINDING_CALL
-Mock_glGetInteger64i_v(GLenum target, GLuint index, GLint64* data);
+static void GL_BINDING_CALL Mock_glGetInteger64i_v(GLenum target,
+                                                   GLuint index,
+                                                   GLint64* data);
 static void GL_BINDING_CALL Mock_glGetInteger64v(GLenum pname, GLint64* params);
-static void GL_BINDING_CALL
-Mock_glGetIntegeri_v(GLenum target, GLuint index, GLint* data);
+static void GL_BINDING_CALL Mock_glGetIntegeri_v(GLenum target,
+                                                 GLuint index,
+                                                 GLint* data);
 static void GL_BINDING_CALL Mock_glGetIntegerv(GLenum pname, GLint* params);
 static void GL_BINDING_CALL Mock_glGetInternalformativ(GLenum target,
                                                        GLenum internalformat,
@@ -456,43 +478,60 @@ static GLint GL_BINDING_CALL
 Mock_glGetProgramResourceLocation(GLuint program,
                                   GLenum programInterface,
                                   const char* name);
-static void GL_BINDING_CALL
-Mock_glGetProgramiv(GLuint program, GLenum pname, GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjectiv(GLuint id, GLenum pname, GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjectivEXT(GLuint id, GLenum pname, GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryiv(GLenum target, GLenum pname, GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryivARB(GLenum target, GLenum pname, GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetQueryivEXT(GLenum target, GLenum pname, GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params);
+static void GL_BINDING_CALL Mock_glGetProgramiv(GLuint program,
+                                                GLenum pname,
+                                                GLint* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjecti64v(GLuint id,
+                                                      GLenum pname,
+                                                      GLint64* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjecti64vEXT(GLuint id,
+                                                         GLenum pname,
+                                                         GLint64* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjectiv(GLuint id,
+                                                    GLenum pname,
+                                                    GLint* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjectivARB(GLuint id,
+                                                       GLenum pname,
+                                                       GLint* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjectivEXT(GLuint id,
+                                                       GLenum pname,
+                                                       GLint* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjectui64v(GLuint id,
+                                                       GLenum pname,
+                                                       GLuint64* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjectui64vEXT(GLuint id,
+                                                          GLenum pname,
+                                                          GLuint64* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjectuiv(GLuint id,
+                                                     GLenum pname,
+                                                     GLuint* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjectuivARB(GLuint id,
+                                                        GLenum pname,
+                                                        GLuint* params);
+static void GL_BINDING_CALL Mock_glGetQueryObjectuivEXT(GLuint id,
+                                                        GLenum pname,
+                                                        GLuint* params);
+static void GL_BINDING_CALL Mock_glGetQueryiv(GLenum target,
+                                              GLenum pname,
+                                              GLint* params);
+static void GL_BINDING_CALL Mock_glGetQueryivARB(GLenum target,
+                                                 GLenum pname,
+                                                 GLint* params);
+static void GL_BINDING_CALL Mock_glGetQueryivEXT(GLenum target,
+                                                 GLenum pname,
+                                                 GLint* params);
+static void GL_BINDING_CALL Mock_glGetRenderbufferParameteriv(GLenum target,
+                                                              GLenum pname,
+                                                              GLint* params);
 static void GL_BINDING_CALL Mock_glGetRenderbufferParameterivEXT(GLenum target,
                                                                  GLenum pname,
                                                                  GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params);
-static void GL_BINDING_CALL
-Mock_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params);
+static void GL_BINDING_CALL Mock_glGetSamplerParameterfv(GLuint sampler,
+                                                         GLenum pname,
+                                                         GLfloat* params);
+static void GL_BINDING_CALL Mock_glGetSamplerParameteriv(GLuint sampler,
+                                                         GLenum pname,
+                                                         GLint* params);
 static void GL_BINDING_CALL Mock_glGetShaderInfoLog(GLuint shader,
                                                     GLsizei bufsize,
                                                     GLsizei* length,
@@ -506,11 +545,12 @@ static void GL_BINDING_CALL Mock_glGetShaderSource(GLuint shader,
                                                    GLsizei bufsize,
                                                    GLsizei* length,
                                                    char* source);
-static void GL_BINDING_CALL
-Mock_glGetShaderiv(GLuint shader, GLenum pname, GLint* params);
+static void GL_BINDING_CALL Mock_glGetShaderiv(GLuint shader,
+                                               GLenum pname,
+                                               GLint* params);
 static const GLubyte* GL_BINDING_CALL Mock_glGetString(GLenum name);
-static const GLubyte* GL_BINDING_CALL
-Mock_glGetStringi(GLenum name, GLuint index);
+static const GLubyte* GL_BINDING_CALL Mock_glGetStringi(GLenum name,
+                                                        GLuint index);
 static void GL_BINDING_CALL Mock_glGetSynciv(GLsync sync,
                                              GLenum pname,
                                              GLsizei bufSize,
@@ -524,10 +564,12 @@ static void GL_BINDING_CALL Mock_glGetTexLevelParameteriv(GLenum target,
                                                           GLint level,
                                                           GLenum pname,
                                                           GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);
-static void GL_BINDING_CALL
-Mock_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params);
+static void GL_BINDING_CALL Mock_glGetTexParameterfv(GLenum target,
+                                                     GLenum pname,
+                                                     GLfloat* params);
+static void GL_BINDING_CALL Mock_glGetTexParameteriv(GLenum target,
+                                                     GLenum pname,
+                                                     GLint* params);
 static void GL_BINDING_CALL Mock_glGetTransformFeedbackVarying(GLuint program,
                                                                GLuint index,
                                                                GLsizei bufSize,
@@ -547,23 +589,29 @@ Mock_glGetUniformIndices(GLuint program,
                          GLsizei uniformCount,
                          const char* const* uniformNames,
                          GLuint* uniformIndices);
-static GLint GL_BINDING_CALL
-Mock_glGetUniformLocation(GLuint program, const char* name);
-static void GL_BINDING_CALL
-Mock_glGetUniformfv(GLuint program, GLint location, GLfloat* params);
-static void GL_BINDING_CALL
-Mock_glGetUniformiv(GLuint program, GLint location, GLint* params);
-static void GL_BINDING_CALL
-Mock_glGetUniformuiv(GLuint program, GLint location, GLuint* params);
-static void GL_BINDING_CALL
-Mock_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer);
-static void GL_BINDING_CALL
-Mock_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params);
-static void GL_BINDING_CALL
-Mock_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params);
+static GLint GL_BINDING_CALL Mock_glGetUniformLocation(GLuint program,
+                                                       const char* name);
+static void GL_BINDING_CALL Mock_glGetUniformfv(GLuint program,
+                                                GLint location,
+                                                GLfloat* params);
+static void GL_BINDING_CALL Mock_glGetUniformiv(GLuint program,
+                                                GLint location,
+                                                GLint* params);
+static void GL_BINDING_CALL Mock_glGetUniformuiv(GLuint program,
+                                                 GLint location,
+                                                 GLuint* params);
+static void GL_BINDING_CALL Mock_glGetVertexAttribPointerv(GLuint index,
+                                                           GLenum pname,
+                                                           void** pointer);
+static void GL_BINDING_CALL Mock_glGetVertexAttribfv(GLuint index,
+                                                     GLenum pname,
+                                                     GLfloat* params);
+static void GL_BINDING_CALL Mock_glGetVertexAttribiv(GLuint index,
+                                                     GLenum pname,
+                                                     GLint* params);
 static void GL_BINDING_CALL Mock_glHint(GLenum target, GLenum mode);
-static void GL_BINDING_CALL
-Mock_glInsertEventMarkerEXT(GLsizei length, const char* marker);
+static void GL_BINDING_CALL Mock_glInsertEventMarkerEXT(GLsizei length,
+                                                        const char* marker);
 static void GL_BINDING_CALL
 Mock_glInvalidateFramebuffer(GLenum target,
                              GLsizei numAttachments,
@@ -582,6 +630,7 @@ static GLboolean GL_BINDING_CALL Mock_glIsFenceAPPLE(GLuint fence);
 static GLboolean GL_BINDING_CALL Mock_glIsFenceNV(GLuint fence);
 static GLboolean GL_BINDING_CALL Mock_glIsFramebuffer(GLuint framebuffer);
 static GLboolean GL_BINDING_CALL Mock_glIsFramebufferEXT(GLuint framebuffer);
+static GLboolean GL_BINDING_CALL Mock_glIsPathNV(GLuint path);
 static GLboolean GL_BINDING_CALL Mock_glIsProgram(GLuint program);
 static GLboolean GL_BINDING_CALL Mock_glIsQuery(GLuint query);
 static GLboolean GL_BINDING_CALL Mock_glIsQueryARB(GLuint query);
@@ -609,8 +658,23 @@ static void* GL_BINDING_CALL Mock_glMapBufferRangeEXT(GLenum target,
                                                       GLsizeiptr length,
                                                       GLbitfield access);
 static void GL_BINDING_CALL Mock_glMatrixLoadIdentityEXT(GLenum matrixMode);
-static void GL_BINDING_CALL
-Mock_glMatrixLoadfEXT(GLenum matrixMode, const GLfloat* m);
+static void GL_BINDING_CALL Mock_glMatrixLoadfEXT(GLenum matrixMode,
+                                                  const GLfloat* m);
+static void GL_BINDING_CALL Mock_glPathCommandsNV(GLuint path,
+                                                  GLsizei numCommands,
+                                                  const GLubyte* commands,
+                                                  GLsizei numCoords,
+                                                  GLenum coordType,
+                                                  const GLvoid* coords);
+static void GL_BINDING_CALL Mock_glPathParameterfNV(GLuint path,
+                                                    GLenum pname,
+                                                    GLfloat value);
+static void GL_BINDING_CALL Mock_glPathParameteriNV(GLuint path,
+                                                    GLenum pname,
+                                                    GLint value);
+static void GL_BINDING_CALL Mock_glPathStencilFuncNV(GLenum func,
+                                                     GLint ref,
+                                                     GLuint mask);
 static void GL_BINDING_CALL Mock_glPauseTransformFeedback(void);
 static void GL_BINDING_CALL Mock_glPixelStorei(GLenum pname, GLint param);
 static void GL_BINDING_CALL Mock_glPointParameteri(GLenum pname, GLint param);
@@ -624,10 +688,11 @@ static void GL_BINDING_CALL Mock_glProgramBinaryOES(GLuint program,
                                                     GLenum binaryFormat,
                                                     const GLvoid* binary,
                                                     GLsizei length);
-static void GL_BINDING_CALL
-Mock_glProgramParameteri(GLuint program, GLenum pname, GLint value);
-static void GL_BINDING_CALL
-Mock_glPushGroupMarkerEXT(GLsizei length, const char* marker);
+static void GL_BINDING_CALL Mock_glProgramParameteri(GLuint program,
+                                                     GLenum pname,
+                                                     GLint value);
+static void GL_BINDING_CALL Mock_glPushGroupMarkerEXT(GLsizei length,
+                                                      const char* marker);
 static void GL_BINDING_CALL Mock_glQueryCounter(GLuint id, GLenum target);
 static void GL_BINDING_CALL Mock_glQueryCounterEXT(GLuint id, GLenum target);
 static void GL_BINDING_CALL Mock_glReadBuffer(GLenum src);
@@ -672,18 +737,24 @@ Mock_glRenderbufferStorageMultisampleIMG(GLenum target,
                                          GLsizei width,
                                          GLsizei height);
 static void GL_BINDING_CALL Mock_glResumeTransformFeedback(void);
-static void GL_BINDING_CALL
-Mock_glSampleCoverage(GLclampf value, GLboolean invert);
-static void GL_BINDING_CALL
-Mock_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-static void GL_BINDING_CALL
-Mock_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* params);
-static void GL_BINDING_CALL
-Mock_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-static void GL_BINDING_CALL
-Mock_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* params);
-static void GL_BINDING_CALL
-Mock_glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+static void GL_BINDING_CALL Mock_glSampleCoverage(GLclampf value,
+                                                  GLboolean invert);
+static void GL_BINDING_CALL Mock_glSamplerParameterf(GLuint sampler,
+                                                     GLenum pname,
+                                                     GLfloat param);
+static void GL_BINDING_CALL Mock_glSamplerParameterfv(GLuint sampler,
+                                                      GLenum pname,
+                                                      const GLfloat* params);
+static void GL_BINDING_CALL Mock_glSamplerParameteri(GLuint sampler,
+                                                     GLenum pname,
+                                                     GLint param);
+static void GL_BINDING_CALL Mock_glSamplerParameteriv(GLuint sampler,
+                                                      GLenum pname,
+                                                      const GLint* params);
+static void GL_BINDING_CALL Mock_glScissor(GLint x,
+                                           GLint y,
+                                           GLsizei width,
+                                           GLsizei height);
 static void GL_BINDING_CALL Mock_glSetFenceAPPLE(GLuint fence);
 static void GL_BINDING_CALL Mock_glSetFenceNV(GLuint fence, GLenum condition);
 static void GL_BINDING_CALL Mock_glShaderBinary(GLsizei n,
@@ -695,17 +766,38 @@ static void GL_BINDING_CALL Mock_glShaderSource(GLuint shader,
                                                 GLsizei count,
                                                 const char* const* str,
                                                 const GLint* length);
-static void GL_BINDING_CALL
-Mock_glStencilFunc(GLenum func, GLint ref, GLuint mask);
-static void GL_BINDING_CALL
-Mock_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
+static void GL_BINDING_CALL Mock_glStencilFillPathNV(GLuint path,
+                                                     GLenum fillMode,
+                                                     GLuint mask);
+static void GL_BINDING_CALL Mock_glStencilFunc(GLenum func,
+                                               GLint ref,
+                                               GLuint mask);
+static void GL_BINDING_CALL Mock_glStencilFuncSeparate(GLenum face,
+                                                       GLenum func,
+                                                       GLint ref,
+                                                       GLuint mask);
 static void GL_BINDING_CALL Mock_glStencilMask(GLuint mask);
-static void GL_BINDING_CALL
-Mock_glStencilMaskSeparate(GLenum face, GLuint mask);
-static void GL_BINDING_CALL
-Mock_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-static void GL_BINDING_CALL
-Mock_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
+static void GL_BINDING_CALL Mock_glStencilMaskSeparate(GLenum face,
+                                                       GLuint mask);
+static void GL_BINDING_CALL Mock_glStencilOp(GLenum fail,
+                                             GLenum zfail,
+                                             GLenum zpass);
+static void GL_BINDING_CALL Mock_glStencilOpSeparate(GLenum face,
+                                                     GLenum fail,
+                                                     GLenum zfail,
+                                                     GLenum zpass);
+static void GL_BINDING_CALL Mock_glStencilStrokePathNV(GLuint path,
+                                                       GLint reference,
+                                                       GLuint mask);
+static void GL_BINDING_CALL Mock_glStencilThenCoverFillPathNV(GLuint path,
+                                                              GLenum fillMode,
+                                                              GLuint mask,
+                                                              GLenum coverMode);
+static void GL_BINDING_CALL
+Mock_glStencilThenCoverStrokePathNV(GLuint path,
+                                    GLint reference,
+                                    GLuint mask,
+                                    GLenum coverMode);
 static GLboolean GL_BINDING_CALL Mock_glTestFenceAPPLE(GLuint fence);
 static GLboolean GL_BINDING_CALL Mock_glTestFenceNV(GLuint fence);
 static void GL_BINDING_CALL Mock_glTexImage2D(GLenum target,
@@ -727,14 +819,18 @@ static void GL_BINDING_CALL Mock_glTexImage3D(GLenum target,
                                               GLenum format,
                                               GLenum type,
                                               const void* pixels);
-static void GL_BINDING_CALL
-Mock_glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-static void GL_BINDING_CALL
-Mock_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
-static void GL_BINDING_CALL
-Mock_glTexParameteri(GLenum target, GLenum pname, GLint param);
-static void GL_BINDING_CALL
-Mock_glTexParameteriv(GLenum target, GLenum pname, const GLint* params);
+static void GL_BINDING_CALL Mock_glTexParameterf(GLenum target,
+                                                 GLenum pname,
+                                                 GLfloat param);
+static void GL_BINDING_CALL Mock_glTexParameterfv(GLenum target,
+                                                  GLenum pname,
+                                                  const GLfloat* params);
+static void GL_BINDING_CALL Mock_glTexParameteri(GLenum target,
+                                                 GLenum pname,
+                                                 GLint param);
+static void GL_BINDING_CALL Mock_glTexParameteriv(GLenum target,
+                                                  GLenum pname,
+                                                  const GLint* params);
 static void GL_BINDING_CALL Mock_glTexStorage2D(GLenum target,
                                                 GLsizei levels,
                                                 GLenum internalformat,
@@ -777,49 +873,69 @@ Mock_glTransformFeedbackVaryings(GLuint program,
                                  const char* const* varyings,
                                  GLenum bufferMode);
 static void GL_BINDING_CALL Mock_glUniform1f(GLint location, GLfloat x);
-static void GL_BINDING_CALL
-Mock_glUniform1fv(GLint location, GLsizei count, const GLfloat* v);
+static void GL_BINDING_CALL Mock_glUniform1fv(GLint location,
+                                              GLsizei count,
+                                              const GLfloat* v);
 static void GL_BINDING_CALL Mock_glUniform1i(GLint location, GLint x);
-static void GL_BINDING_CALL
-Mock_glUniform1iv(GLint location, GLsizei count, const GLint* v);
+static void GL_BINDING_CALL Mock_glUniform1iv(GLint location,
+                                              GLsizei count,
+                                              const GLint* v);
 static void GL_BINDING_CALL Mock_glUniform1ui(GLint location, GLuint v0);
-static void GL_BINDING_CALL
-Mock_glUniform1uiv(GLint location, GLsizei count, const GLuint* v);
-static void GL_BINDING_CALL
-Mock_glUniform2f(GLint location, GLfloat x, GLfloat y);
-static void GL_BINDING_CALL
-Mock_glUniform2fv(GLint location, GLsizei count, const GLfloat* v);
+static void GL_BINDING_CALL Mock_glUniform1uiv(GLint location,
+                                               GLsizei count,
+                                               const GLuint* v);
+static void GL_BINDING_CALL Mock_glUniform2f(GLint location,
+                                             GLfloat x,
+                                             GLfloat y);
+static void GL_BINDING_CALL Mock_glUniform2fv(GLint location,
+                                              GLsizei count,
+                                              const GLfloat* v);
 static void GL_BINDING_CALL Mock_glUniform2i(GLint location, GLint x, GLint y);
-static void GL_BINDING_CALL
-Mock_glUniform2iv(GLint location, GLsizei count, const GLint* v);
-static void GL_BINDING_CALL
-Mock_glUniform2ui(GLint location, GLuint v0, GLuint v1);
-static void GL_BINDING_CALL
-Mock_glUniform2uiv(GLint location, GLsizei count, const GLuint* v);
-static void GL_BINDING_CALL
-Mock_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);
-static void GL_BINDING_CALL
-Mock_glUniform3fv(GLint location, GLsizei count, const GLfloat* v);
-static void GL_BINDING_CALL
-Mock_glUniform3i(GLint location, GLint x, GLint y, GLint z);
-static void GL_BINDING_CALL
-Mock_glUniform3iv(GLint location, GLsizei count, const GLint* v);
-static void GL_BINDING_CALL
-Mock_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-static void GL_BINDING_CALL
-Mock_glUniform3uiv(GLint location, GLsizei count, const GLuint* v);
+static void GL_BINDING_CALL Mock_glUniform2iv(GLint location,
+                                              GLsizei count,
+                                              const GLint* v);
+static void GL_BINDING_CALL Mock_glUniform2ui(GLint location,
+                                              GLuint v0,
+                                              GLuint v1);
+static void GL_BINDING_CALL Mock_glUniform2uiv(GLint location,
+                                               GLsizei count,
+                                               const GLuint* v);
+static void GL_BINDING_CALL Mock_glUniform3f(GLint location,
+                                             GLfloat x,
+                                             GLfloat y,
+                                             GLfloat z);
+static void GL_BINDING_CALL Mock_glUniform3fv(GLint location,
+                                              GLsizei count,
+                                              const GLfloat* v);
+static void GL_BINDING_CALL Mock_glUniform3i(GLint location,
+                                             GLint x,
+                                             GLint y,
+                                             GLint z);
+static void GL_BINDING_CALL Mock_glUniform3iv(GLint location,
+                                              GLsizei count,
+                                              const GLint* v);
+static void GL_BINDING_CALL Mock_glUniform3ui(GLint location,
+                                              GLuint v0,
+                                              GLuint v1,
+                                              GLuint v2);
+static void GL_BINDING_CALL Mock_glUniform3uiv(GLint location,
+                                               GLsizei count,
+                                               const GLuint* v);
 static void GL_BINDING_CALL
 Mock_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-static void GL_BINDING_CALL
-Mock_glUniform4fv(GLint location, GLsizei count, const GLfloat* v);
+static void GL_BINDING_CALL Mock_glUniform4fv(GLint location,
+                                              GLsizei count,
+                                              const GLfloat* v);
 static void GL_BINDING_CALL
 Mock_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);
-static void GL_BINDING_CALL
-Mock_glUniform4iv(GLint location, GLsizei count, const GLint* v);
+static void GL_BINDING_CALL Mock_glUniform4iv(GLint location,
+                                              GLsizei count,
+                                              const GLint* v);
 static void GL_BINDING_CALL
 Mock_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-static void GL_BINDING_CALL
-Mock_glUniform4uiv(GLint location, GLsizei count, const GLuint* v);
+static void GL_BINDING_CALL Mock_glUniform4uiv(GLint location,
+                                               GLsizei count,
+                                               const GLuint* v);
 static void GL_BINDING_CALL
 Mock_glUniformBlockBinding(GLuint program,
                            GLuint uniformBlockIndex,
@@ -865,34 +981,37 @@ static GLboolean GL_BINDING_CALL Mock_glUnmapBufferOES(GLenum target);
 static void GL_BINDING_CALL Mock_glUseProgram(GLuint program);
 static void GL_BINDING_CALL Mock_glValidateProgram(GLuint program);
 static void GL_BINDING_CALL Mock_glVertexAttrib1f(GLuint indx, GLfloat x);
-static void GL_BINDING_CALL
-Mock_glVertexAttrib1fv(GLuint indx, const GLfloat* values);
-static void GL_BINDING_CALL
-Mock_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
-static void GL_BINDING_CALL
-Mock_glVertexAttrib2fv(GLuint indx, const GLfloat* values);
-static void GL_BINDING_CALL
-Mock_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-static void GL_BINDING_CALL
-Mock_glVertexAttrib3fv(GLuint indx, const GLfloat* values);
+static void GL_BINDING_CALL Mock_glVertexAttrib1fv(GLuint indx,
+                                                   const GLfloat* values);
+static void GL_BINDING_CALL Mock_glVertexAttrib2f(GLuint indx,
+                                                  GLfloat x,
+                                                  GLfloat y);
+static void GL_BINDING_CALL Mock_glVertexAttrib2fv(GLuint indx,
+                                                   const GLfloat* values);
+static void GL_BINDING_CALL Mock_glVertexAttrib3f(GLuint indx,
+                                                  GLfloat x,
+                                                  GLfloat y,
+                                                  GLfloat z);
+static void GL_BINDING_CALL Mock_glVertexAttrib3fv(GLuint indx,
+                                                   const GLfloat* values);
 static void GL_BINDING_CALL
 Mock_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-static void GL_BINDING_CALL
-Mock_glVertexAttrib4fv(GLuint indx, const GLfloat* values);
-static void GL_BINDING_CALL
-Mock_glVertexAttribDivisor(GLuint index, GLuint divisor);
-static void GL_BINDING_CALL
-Mock_glVertexAttribDivisorANGLE(GLuint index, GLuint divisor);
-static void GL_BINDING_CALL
-Mock_glVertexAttribDivisorARB(GLuint index, GLuint divisor);
+static void GL_BINDING_CALL Mock_glVertexAttrib4fv(GLuint indx,
+                                                   const GLfloat* values);
+static void GL_BINDING_CALL Mock_glVertexAttribDivisor(GLuint index,
+                                                       GLuint divisor);
+static void GL_BINDING_CALL Mock_glVertexAttribDivisorANGLE(GLuint index,
+                                                            GLuint divisor);
+static void GL_BINDING_CALL Mock_glVertexAttribDivisorARB(GLuint index,
+                                                          GLuint divisor);
 static void GL_BINDING_CALL
 Mock_glVertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w);
-static void GL_BINDING_CALL
-Mock_glVertexAttribI4iv(GLuint indx, const GLint* values);
+static void GL_BINDING_CALL Mock_glVertexAttribI4iv(GLuint indx,
+                                                    const GLint* values);
 static void GL_BINDING_CALL
 Mock_glVertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w);
-static void GL_BINDING_CALL
-Mock_glVertexAttribI4uiv(GLuint indx, const GLuint* values);
+static void GL_BINDING_CALL Mock_glVertexAttribI4uiv(GLuint indx,
+                                                     const GLuint* values);
 static void GL_BINDING_CALL Mock_glVertexAttribIPointer(GLuint indx,
                                                         GLint size,
                                                         GLenum type,
@@ -904,7 +1023,10 @@ static void GL_BINDING_CALL Mock_glVertexAttribPointer(GLuint indx,
                                                        GLboolean normalized,
                                                        GLsizei stride,
                                                        const void* ptr);
-static void GL_BINDING_CALL
-Mock_glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-static GLenum GL_BINDING_CALL
-Mock_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+static void GL_BINDING_CALL Mock_glViewport(GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height);
+static GLenum GL_BINDING_CALL Mock_glWaitSync(GLsync sync,
+                                              GLbitfield flags,
+                                              GLuint64 timeout);
diff --git a/chromium/ui/gl/gl_bindings_autogen_wgl.cc b/chromium/ui/gl/gl_bindings_autogen_wgl.cc
index e5642e348f7..221efb080b8 100644
--- a/chromium/ui/gl/gl_bindings_autogen_wgl.cc
+++ b/chromium/ui/gl/gl_bindings_autogen_wgl.cc
@@ -149,8 +149,9 @@ Debug_wglChoosePixelFormatARB(HDC dc,
   return result;
 }
 
-static BOOL GL_BINDING_CALL
-Debug_wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask) {
+static BOOL GL_BINDING_CALL Debug_wglCopyContext(HGLRC hglrcSrc,
+                                                 HGLRC hglrcDst,
+                                                 UINT mask) {
   GL_SERVICE_LOG("wglCopyContext"
                  << "(" << hglrcSrc << ", " << hglrcDst << ", " << mask << ")");
   BOOL result =
@@ -167,8 +168,8 @@ static HGLRC GL_BINDING_CALL Debug_wglCreateContext(HDC hdc) {
   return result;
 }
 
-static HGLRC GL_BINDING_CALL
-Debug_wglCreateLayerContext(HDC hdc, int iLayerPlane) {
+static HGLRC GL_BINDING_CALL Debug_wglCreateLayerContext(HDC hdc,
+                                                         int iLayerPlane) {
   GL_SERVICE_LOG("wglCreateLayerContext"
                  << "(" << hdc << ", " << iLayerPlane << ")");
   HGLRC result =
@@ -260,8 +261,9 @@ static BOOL GL_BINDING_CALL Debug_wglMakeCurrent(HDC hdc, HGLRC hglrc) {
   return result;
 }
 
-static BOOL GL_BINDING_CALL
-Debug_wglQueryPbufferARB(HPBUFFERARB hPbuffer, int iAttribute, int* piValue) {
+static BOOL GL_BINDING_CALL Debug_wglQueryPbufferARB(HPBUFFERARB hPbuffer,
+                                                     int iAttribute,
+                                                     int* piValue) {
   GL_SERVICE_LOG("wglQueryPbufferARB"
                  << "(" << hPbuffer << ", " << iAttribute << ", "
                  << static_cast<const void*>(piValue) << ")");
@@ -271,8 +273,8 @@ Debug_wglQueryPbufferARB(HPBUFFERARB hPbuffer, int iAttribute, int* piValue) {
   return result;
 }
 
-static int GL_BINDING_CALL
-Debug_wglReleasePbufferDCARB(HPBUFFERARB hPbuffer, HDC hDC) {
+static int GL_BINDING_CALL Debug_wglReleasePbufferDCARB(HPBUFFERARB hPbuffer,
+                                                        HDC hDC) {
   GL_SERVICE_LOG("wglReleasePbufferDCARB"
                  << "(" << hPbuffer << ", " << hDC << ")");
   int result = g_driver_wgl.debug_fn.wglReleasePbufferDCARBFn(hPbuffer, hDC);
diff --git a/chromium/ui/gl/gl_bindings_skia_in_process.cc b/chromium/ui/gl/gl_bindings_skia_in_process.cc
index fe44954263c..d76bd7aba16 100644
--- a/chromium/ui/gl/gl_bindings_skia_in_process.cc
+++ b/chromium/ui/gl/gl_bindings_skia_in_process.cc
@@ -17,618 +17,794 @@ extern "C" {
 // via gl_bindings.h use call-type GL_BINDING_CALL, which on Windows is stdcall.
 // Skia has been built such that its GrGLInterface GL pointers are __cdecl.
 
-GLvoid StubGLActiveTexture(GLenum texture) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLActiveTexture(GLenum texture) {
   glActiveTexture(texture);
 }
 
-GLvoid StubGLAttachShader(GLuint program, GLuint shader) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLAttachShader(GLuint program, GLuint shader) {
   glAttachShader(program, shader);
 }
 
-GLvoid StubGLBeginQuery(GLenum target, GLuint id) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBeginQuery(GLenum target, GLuint id) {
   glBeginQuery(target, id);
 }
 
-GLvoid StubGLBindAttribLocation(GLuint program, GLuint index,
-                                const char* name) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindAttribLocation(GLuint program,
+                                                    GLuint index,
+                                                    const char* name) {
   glBindAttribLocation(program, index, name);
 }
 
-GLvoid StubGLBindBuffer(GLenum target, GLuint buffer) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindBuffer(GLenum target, GLuint buffer) {
   glBindBuffer(target, buffer);
 }
 
-GLvoid StubGLBindFragDataLocation(GLuint program, GLuint colorNumber,
-                                  const GLchar * name) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindFragDataLocation(GLuint program,
+                                                      GLuint colorNumber,
+                                                      const GLchar* name) {
   glBindFragDataLocation(program, colorNumber, name);
 }
 
-GLvoid StubGLBindFragDataLocationIndexed(GLuint program, GLuint colorNumber,
-                                         GLuint index, const GLchar * name) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLBindFragDataLocationIndexed(GLuint program,
+                                  GLuint colorNumber,
+                                  GLuint index,
+                                  const GLchar* name) {
   glBindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
-GLvoid StubGLBindFramebuffer(GLenum target, GLuint framebuffer) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindFramebuffer(GLenum target,
+                                                 GLuint framebuffer) {
   glBindFramebufferEXT(target, framebuffer);
 }
 
-GLvoid StubGLBindRenderbuffer(GLenum target, GLuint renderbuffer) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindRenderbuffer(GLenum target,
+                                                  GLuint renderbuffer) {
   glBindRenderbufferEXT(target, renderbuffer);
 }
 
-GLvoid StubGLBindTexture(GLenum target, GLuint texture) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindTexture(GLenum target, GLuint texture) {
   glBindTexture(target, texture);
 }
 
-GLvoid StubGLBindVertexArray(GLuint array) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindVertexArray(GLuint array) {
   glBindVertexArrayOES(array);
 }
 
-GLvoid StubGLBlendBarrier() {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlendBarrier() {
   glBlendBarrierKHR();
 }
 
-GLvoid StubGLBlendColor(GLclampf red, GLclampf green, GLclampf blue,
-                        GLclampf alpha) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlendColor(GLclampf red,
+                                            GLclampf green,
+                                            GLclampf blue,
+                                            GLclampf alpha) {
   glBlendColor(red, green, blue, alpha);
 }
 
-GLvoid StubGLBlendEquation(GLenum mode) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlendEquation(GLenum mode) {
   glBlendEquation(mode);
 }
 
-GLvoid StubGLBlendFunc(GLenum sfactor, GLenum dfactor) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlendFunc(GLenum sfactor, GLenum dfactor) {
   glBlendFunc(sfactor, dfactor);
 }
 
-GLvoid StubGLBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                             GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                             GLbitfield mask, GLenum filter) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlitFramebuffer(GLint srcX0,
+                                                 GLint srcY0,
+                                                 GLint srcX1,
+                                                 GLint srcY1,
+                                                 GLint dstX0,
+                                                 GLint dstY0,
+                                                 GLint dstX1,
+                                                 GLint dstY1,
+                                                 GLbitfield mask,
+                                                 GLenum filter) {
   glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
                        mask, filter);
 }
 
-GLvoid StubGLBufferData(GLenum target, GLsizeiptr size, const void* data,
-                        GLenum usage) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBufferData(GLenum target,
+                                            GLsizeiptr size,
+                                            const void* data,
+                                            GLenum usage) {
   glBufferData(target, size, data, usage);
 }
 
-GLvoid StubGLBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
-                           const void* data) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBufferSubData(GLenum target,
+                                               GLintptr offset,
+                                               GLsizeiptr size,
+                                               const void* data) {
   glBufferSubData(target, offset, size, data);
 }
 
-GLenum StubGLCheckFramebufferStatus(GLenum target) {
+GLenum GR_GL_FUNCTION_TYPE StubGLCheckFramebufferStatus(GLenum target) {
   return glCheckFramebufferStatusEXT(target);
 }
 
-GLvoid StubGLClear(GLbitfield mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLClear(GLbitfield mask) {
   glClear(mask);
 }
 
-GLvoid StubGLClearColor(GLclampf red, GLclampf green, GLclampf blue,
-                        GLclampf alpha) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLClearColor(GLclampf red,
+                                            GLclampf green,
+                                            GLclampf blue,
+                                            GLclampf alpha) {
   glClearColor(red, green, blue, alpha);
 }
 
-GLvoid StubGLClearStencil(GLint s) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLClearStencil(GLint s) {
   glClearStencil(s);
 }
 
-GLvoid StubGLColorMask(GLboolean red, GLboolean green, GLboolean blue,
-                       GLboolean alpha) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLColorMask(GLboolean red,
+                                           GLboolean green,
+                                           GLboolean blue,
+                                           GLboolean alpha) {
   glColorMask(red, green, blue, alpha);
 }
 
-GLvoid StubGLCompileShader(GLuint shader) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLCompileShader(GLuint shader) {
   glCompileShader(shader);
 }
 
-GLvoid StubGLCompressedTexImage2D(GLenum target, GLint level,
-                                  GLenum internalformat, GLsizei width,
-                                  GLsizei height, GLint border,
-                                  GLsizei imageSize, const void* data) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLCompressedTexImage2D(GLenum target,
+                                                      GLint level,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLint border,
+                                                      GLsizei imageSize,
+                                                      const void* data) {
   glCompressedTexImage2D(target, level, internalformat, width, height, border,
                          imageSize, data);
 }
 
-GLvoid StubGLCopyTexSubImage2D(GLenum target, GLint level,
-                               GLint xoffset, GLint yoffset,
-                               GLint x, GLint y,
-                               GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLCopyTexSubImage2D(GLenum target,
+                                                   GLint level,
+                                                   GLint xoffset,
+                                                   GLint yoffset,
+                                                   GLint x,
+                                                   GLint y,
+                                                   GLsizei width,
+                                                   GLsizei height) {
   glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
-GLuint StubGLCreateProgram(void) {
+GLuint GR_GL_FUNCTION_TYPE StubGLCreateProgram(void) {
   return glCreateProgram();
 }
 
-GLuint StubGLCreateShader(GLenum type) {
+GLuint GR_GL_FUNCTION_TYPE StubGLCreateShader(GLenum type) {
   return glCreateShader(type);
 }
 
-GLvoid StubGLCullFace(GLenum mode) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLCullFace(GLenum mode) {
   glCullFace(mode);
 }
 
-GLvoid StubGLDeleteBuffers(GLsizei n, const GLuint* buffers) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteBuffers(GLsizei n,
+                                               const GLuint* buffers) {
   glDeleteBuffersARB(n, buffers);
 }
 
-GLvoid StubGLDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
   glDeleteFramebuffersEXT(n, framebuffers);
 }
 
-GLvoid StubGLDeleteQueries(GLsizei n, const GLuint* ids) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteQueries(GLsizei n, const GLuint* ids) {
   glDeleteQueries(n, ids);
 }
 
-GLvoid StubGLDeleteProgram(GLuint program) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteProgram(GLuint program) {
   glDeleteProgram(program);
 }
 
-GLvoid StubGLDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
   glDeleteRenderbuffersEXT(n, renderbuffers);
 }
 
-GLvoid StubGLDeleteShader(GLuint shader) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteShader(GLuint shader) {
   glDeleteShader(shader);
 }
 
-GLvoid StubGLDeleteTextures(GLsizei n, const GLuint* textures) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteTextures(GLsizei n,
+                                                const GLuint* textures) {
   glDeleteTextures(n, textures);
 }
 
-GLvoid StubGLDeleteVertexArrays(GLsizei n, const GLuint* arrays) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteVertexArrays(GLsizei n,
+                                                    const GLuint* arrays) {
   glDeleteVertexArraysOES(n, arrays);
 }
 
-GLvoid StubGLDepthMask(GLboolean flag) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDepthMask(GLboolean flag) {
   glDepthMask(flag);
 }
 
-GLvoid StubGLDisable(GLenum cap) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDisable(GLenum cap) {
   glDisable(cap);
 }
 
-GLvoid StubGLDisableVertexAttribArray(GLuint index) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDisableVertexAttribArray(GLuint index) {
   glDisableVertexAttribArray(index);
 }
 
-GLvoid StubGLDiscardFramebuffer(GLenum target, GLsizei numAttachments,
-                                const GLenum *attachments) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDiscardFramebuffer(GLenum target,
+                                                    GLsizei numAttachments,
+                                                    const GLenum* attachments) {
   glDiscardFramebufferEXT(target, numAttachments, attachments);
 }
 
-GLvoid StubGLDrawArrays(GLenum mode, GLint first, GLsizei count) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDrawArrays(GLenum mode,
+                                            GLint first,
+                                            GLsizei count) {
   glDrawArrays(mode, first, count);
 }
 
-GLvoid StubGLDrawBuffer(GLenum mode) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDrawBuffer(GLenum mode) {
   glDrawBuffer(mode);
 }
 
-GLvoid StubGLDrawBuffers(GLsizei n, const GLenum* bufs) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDrawBuffers(GLsizei n, const GLenum* bufs) {
   glDrawBuffersARB(n, bufs);
 }
 
-GLvoid StubGLDrawElements(GLenum mode, GLsizei count, GLenum type,
-                          const void* indices) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDrawElements(GLenum mode,
+                                              GLsizei count,
+                                              GLenum type,
+                                              const void* indices) {
   glDrawElements(mode, count, type, indices);
 }
 
-GLvoid StubGLEnable(GLenum cap) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLEnable(GLenum cap) {
   glEnable(cap);
 }
 
-GLvoid StubGLEnableVertexAttribArray(GLuint index) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLEnableVertexAttribArray(GLuint index) {
   glEnableVertexAttribArray(index);
 }
 
-GLvoid StubGLEndQuery(GLenum target) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLEndQuery(GLenum target) {
   glEndQuery(target);
 }
 
-GLvoid StubGLFinish() {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFinish() {
   glFinish();
 }
 
-GLvoid StubGLFlush() {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFlush() {
   glFlush();
 }
 
-GLvoid StubGLFlushMappedBufferRange(GLenum target, GLintptr offset,
-                                    GLsizeiptr length) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFlushMappedBufferRange(GLenum target,
+                                                        GLintptr offset,
+                                                        GLsizeiptr length) {
   glFlushMappedBufferRange(target, offset, length);
 }
 
-GLvoid StubGLFramebufferRenderbuffer(GLenum target, GLenum attachment,
-                                     GLenum renderbuffertarget,
-                                     GLuint renderbuffer) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLFramebufferRenderbuffer(GLenum target,
+                              GLenum attachment,
+                              GLenum renderbuffertarget,
+                              GLuint renderbuffer) {
   glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
                                renderbuffer);
 }
 
-GLvoid StubGLFramebufferTexture2D(GLenum target, GLenum attachment,
-                                  GLenum textarget, GLuint texture,
-                                  GLint level) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFramebufferTexture2D(GLenum target,
+                                                      GLenum attachment,
+                                                      GLenum textarget,
+                                                      GLuint texture,
+                                                      GLint level) {
   glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
 }
 
-GLvoid StubGLFramebufferTexture2DMultisample(GLenum target, GLenum attachment,
-                                  GLenum textarget, GLuint texture,
-                                  GLint level, GLsizei samples) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLFramebufferTexture2DMultisample(GLenum target,
+                                      GLenum attachment,
+                                      GLenum textarget,
+                                      GLuint texture,
+                                      GLint level,
+                                      GLsizei samples) {
   glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture,
       level, samples);
 }
 
-GLvoid StubGLFrontFace(GLenum mode) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFrontFace(GLenum mode) {
   glFrontFace(mode);
 }
 
-GLvoid StubGLGenBuffers(GLsizei n, GLuint* buffers) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenBuffers(GLsizei n, GLuint* buffers) {
   glGenBuffersARB(n, buffers);
 }
 
-GLvoid StubGLGenFramebuffers(GLsizei n, GLuint* framebuffers) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenFramebuffers(GLsizei n,
+                                                 GLuint* framebuffers) {
   glGenFramebuffersEXT(n, framebuffers);
 }
 
-GLvoid StubGLGenQueries(GLsizei n, GLuint* ids) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenQueries(GLsizei n, GLuint* ids) {
   glGenQueries(n, ids);
 }
 
-GLvoid StubGLGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenRenderbuffers(GLsizei n,
+                                                  GLuint* renderbuffers) {
   glGenRenderbuffersEXT(n, renderbuffers);
 }
 
-GLvoid StubGLGenTextures(GLsizei n, GLuint* textures) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenTextures(GLsizei n, GLuint* textures) {
   glGenTextures(n, textures);
 }
 
-GLvoid StubGLGenVertexArrays(GLsizei n, GLuint* arrays) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenVertexArrays(GLsizei n, GLuint* arrays) {
   glGenVertexArraysOES(n, arrays);
 }
 
-GLvoid StubGLGenerateMipmap(GLenum target){
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenerateMipmap(GLenum target) {
   glGenerateMipmapEXT(target);
 }
 
-GLvoid StubGLGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetBufferParameteriv(GLenum target,
+                                                      GLenum pname,
+                                                      GLint* params) {
   glGetBufferParameteriv(target, pname, params);
 }
 
-GLvoid StubGLGetFramebufferAttachmentParameteriv(GLenum target,
-                                                 GLenum attachment,
-                                                 GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLGetFramebufferAttachmentParameteriv(GLenum target,
+                                          GLenum attachment,
+                                          GLenum pname,
+                                          GLint* params) {
   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
 }
 
-GLenum StubGLGetError() {
+GLenum GR_GL_FUNCTION_TYPE StubGLGetError() {
   return glGetError();
 }
 
-GLvoid StubGLGetIntegerv(GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetIntegerv(GLenum pname, GLint* params) {
   glGetIntegerv(pname, params);
 }
 
-GLvoid StubGLGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length,
-                               char* infolog) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetProgramInfoLog(GLuint program,
+                                                   GLsizei bufsize,
+                                                   GLsizei* length,
+                                                   char* infolog) {
   glGetProgramInfoLog(program, bufsize, length, infolog);
 }
 
-GLvoid StubGLGetProgramiv(GLuint program, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetProgramiv(GLuint program,
+                                              GLenum pname,
+                                              GLint* params) {
   glGetProgramiv(program, pname, params);
 }
 
-GLvoid StubGLGetRenderbufferParameteriv(GLenum target,
-                                        GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetRenderbufferParameteriv(GLenum target,
+                                                            GLenum pname,
+                                                            GLint* params) {
   glGetRenderbufferParameterivEXT(target, pname, params);
 }
 
-GLvoid StubGLGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length,
-                              char* infolog) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetShaderInfoLog(GLuint shader,
+                                                  GLsizei bufsize,
+                                                  GLsizei* length,
+                                                  char* infolog) {
   glGetShaderInfoLog(shader, bufsize, length, infolog);
 }
 
-GLvoid StubGLGetShaderiv(GLuint shader, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetShaderiv(GLuint shader,
+                                             GLenum pname,
+                                             GLint* params) {
   glGetShaderiv(shader, pname, params);
 }
 
-GLvoid StubGLGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
-                                      GLint *range, GLint *precision) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetShaderPrecisionFormat(GLenum shadertype,
+                                                          GLenum precisiontype,
+                                                          GLint* range,
+                                                          GLint* precision) {
   glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
-const GLubyte* StubGLGetString(GLenum name) {
+const GLubyte* GR_GL_FUNCTION_TYPE StubGLGetString(GLenum name) {
   return glGetString(name);
 }
 
-const GLubyte* StubGLGetStringi(GLenum name, GLuint index) {
+const GLubyte* GR_GL_FUNCTION_TYPE StubGLGetStringi(GLenum name, GLuint index) {
   return glGetStringi(name, index);
 }
 
-GLvoid StubGLGetQueryiv(GLenum target, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryiv(GLenum target,
+                                            GLenum pname,
+                                            GLint* params) {
   glGetQueryiv(target, pname, params);
 }
 
-GLvoid StubGLGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryObjecti64v(GLuint id,
+                                                    GLenum pname,
+                                                    GLint64* params) {
   glGetQueryObjecti64v(id, pname, params);
 }
 
-GLvoid StubGLGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryObjectiv(GLuint id,
+                                                  GLenum pname,
+                                                  GLint* params) {
   glGetQueryObjectiv(id, pname, params);
 }
 
-GLvoid StubGLGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryObjectui64v(GLuint id,
+                                                     GLenum pname,
+                                                     GLuint64* params) {
   glGetQueryObjectui64v(id, pname, params);
 }
 
-GLvoid StubGLGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryObjectuiv(GLuint id,
+                                                   GLenum pname,
+                                                   GLuint* params) {
   glGetQueryObjectuiv(id, pname, params);
 }
 
-GLvoid StubGLGetTexLevelParameteriv(GLenum target, GLint level,
-                                    GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetTexLevelParameteriv(GLenum target,
+                                                        GLint level,
+                                                        GLenum pname,
+                                                        GLint* params) {
   glGetTexLevelParameteriv(target, level, pname, params);
 }
 
-GLint StubGLGetUniformLocation(GLuint program, const char* name) {
+GLint GR_GL_FUNCTION_TYPE StubGLGetUniformLocation(GLuint program,
+                                                   const char* name) {
   return glGetUniformLocation(program, name);
 }
 
-GLvoid StubGLInsertEventMarker(GLsizei length, const char* marker) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLInsertEventMarker(GLsizei length,
+                                                   const char* marker) {
   glInsertEventMarkerEXT(length, marker);
 }
 
-GLvoid StubGLInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
-                                   const GLenum* attachments) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLInvalidateFramebuffer(GLenum target,
+                            GLsizei numAttachments,
+                            const GLenum* attachments) {
   glInvalidateFramebuffer(target, numAttachments, attachments);
 }
 
-GLvoid StubGLInvalidateSubFramebuffer(GLenum target,
-                                      GLsizei numAttachments,
-                                      const GLenum* attachments,
-                                      GLint x, GLint y,
-                                      GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLInvalidateSubFramebuffer(GLenum target,
+                               GLsizei numAttachments,
+                               const GLenum* attachments,
+                               GLint x,
+                               GLint y,
+                               GLsizei width,
+                               GLsizei height) {
   glInvalidateSubFramebuffer(target, numAttachments, attachments,
                              x, y, width, height);
 }
 
-GLvoid StubGLLineWidth(GLfloat width) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLLineWidth(GLfloat width) {
   glLineWidth(width);
 }
 
-GLvoid StubGLLinkProgram(GLuint program) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLLinkProgram(GLuint program) {
   glLinkProgram(program);
 }
 
-void* StubGLMapBuffer(GLenum target, GLenum access) {
+void* GR_GL_FUNCTION_TYPE StubGLMapBuffer(GLenum target, GLenum access) {
   return glMapBuffer(target, access);
 }
 
-void* StubGLMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
-                           GLbitfield access) {
+void* GR_GL_FUNCTION_TYPE StubGLMapBufferRange(GLenum target,
+                                               GLintptr offset,
+                                               GLsizeiptr length,
+                                               GLbitfield access) {
   return glMapBufferRange(target, offset, length, access);
 }
 
-GLvoid StubGLPixelStorei(GLenum pname, GLint param) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLPixelStorei(GLenum pname, GLint param) {
   glPixelStorei(pname, param);
 }
 
-GLvoid StubGLPopGroupMarker() {
+GLvoid GR_GL_FUNCTION_TYPE StubGLPopGroupMarker() {
   glPopGroupMarkerEXT();
 }
 
-GLvoid StubGLPushGroupMarker(GLsizei length, const char* marker) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLPushGroupMarker(GLsizei length,
+                                                 const char* marker) {
   glPushGroupMarkerEXT(length, marker);
 }
 
-GLvoid StubGLQueryCounter(GLuint id, GLenum target) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLQueryCounter(GLuint id, GLenum target) {
   glQueryCounter(id, target);
 }
 
-GLvoid StubGLReadBuffer(GLenum src) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLReadBuffer(GLenum src) {
   glReadBuffer(src);
 }
 
-GLvoid StubGLReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
-                        GLenum format, GLenum type, void* pixels) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLReadPixels(GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            void* pixels) {
   glReadPixels(x, y, width, height, format, type, pixels);
 }
 
-GLvoid StubGLRenderbufferStorage(GLenum target, GLenum internalformat,
-                                 GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLRenderbufferStorage(GLenum target,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height) {
   glRenderbufferStorageEXT(target, internalformat, width, height);
 }
 
-GLvoid StubGLRenderbufferStorageMultisample(GLenum target, GLsizei samples,
-                                            GLenum internalformat,
-                                            GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLRenderbufferStorageMultisample(GLenum target,
+                                     GLsizei samples,
+                                     GLenum internalformat,
+                                     GLsizei width,
+                                     GLsizei height) {
   glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width,
                                       height);
 }
 
-GLvoid StubGLScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLScissor(GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height) {
   glScissor(x, y, width, height);
 }
 
-GLvoid StubGLShaderSource(GLuint shader, GLsizei count, const char* const* str,
-                          const GLint* length) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLShaderSource(GLuint shader,
+                                              GLsizei count,
+                                              const char* const* str,
+                                              const GLint* length) {
   glShaderSource(shader, count, str, length);
 }
 
-GLvoid StubGLStencilFunc(GLenum func, GLint ref, GLuint mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilFunc(GLenum func,
+                                             GLint ref,
+                                             GLuint mask) {
   glStencilFunc(func, ref, mask);
 }
 
-GLvoid StubGLStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
-                                 GLuint mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilFuncSeparate(GLenum face,
+                                                     GLenum func,
+                                                     GLint ref,
+                                                     GLuint mask) {
   glStencilFuncSeparate(face, func, ref, mask);
 }
 
-GLvoid StubGLStencilMask(GLuint mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilMask(GLuint mask) {
   glStencilMask(mask);
 }
 
-GLvoid StubGLStencilMaskSeparate(GLenum face, GLuint mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilMaskSeparate(GLenum face, GLuint mask) {
   glStencilMaskSeparate(face, mask);
 }
 
-GLvoid StubGLStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilOp(GLenum fail,
+                                           GLenum zfail,
+                                           GLenum zpass) {
   glStencilOp(fail, zfail, zpass);
 }
 
-GLvoid StubGLStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
-                               GLenum zpass) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilOpSeparate(GLenum face,
+                                                   GLenum fail,
+                                                   GLenum zfail,
+                                                   GLenum zpass) {
   glStencilOpSeparate(face, fail, zfail, zpass);
 }
 
-GLvoid StubGLTexImage2D(GLenum target, GLint level, GLint internalformat,
-                        GLsizei width, GLsizei height, GLint border,
-                        GLenum format, GLenum type, const void* pixels) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexImage2D(GLenum target,
+                                            GLint level,
+                                            GLint internalformat,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLint border,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void* pixels) {
   glTexImage2D(target, level, internalformat, width, height, border, format,
                type, pixels);
 }
 
-GLvoid StubGLTexParameteri(GLenum target, GLenum pname, GLint param) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexParameteri(GLenum target,
+                                               GLenum pname,
+                                               GLint param) {
   glTexParameteri(target, pname, param);
 }
 
-GLvoid StubGLTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexParameteriv(GLenum target,
+                                                GLenum pname,
+                                                const GLint* params) {
   glTexParameteriv(target, pname, params);
 }
 
-GLvoid StubGLTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat,
-                          GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexStorage2D(GLenum target,
+                                              GLsizei levels,
+                                              GLenum internalFormat,
+                                              GLsizei width,
+                                              GLsizei height) {
   glTexStorage2DEXT(target, levels, internalFormat, width, height);
 }
 
-GLvoid StubGLTexSubImage2D(GLenum target, GLint level, GLint xoffset,
-                           GLint yoffset, GLsizei width, GLsizei height,
-                           GLenum format, GLenum type, const void* pixels) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexSubImage2D(GLenum target,
+                                               GLint level,
+                                               GLint xoffset,
+                                               GLint yoffset,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLenum format,
+                                               GLenum type,
+                                               const void* pixels) {
   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
                   pixels);
 }
 
-GLvoid StubGLUniform1f(GLint location, GLfloat v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform1f(GLint location, GLfloat v) {
   glUniform1f(location, v);
 }
 
-GLvoid StubGLUniform1i(GLint location, GLint v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform1i(GLint location, GLint v) {
   glUniform1i(location, v);
 }
 
-GLvoid StubGLUniform1fv(GLint location, GLsizei count, const GLfloat* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform1fv(GLint location,
+                                            GLsizei count,
+                                            const GLfloat* v) {
   glUniform1fv(location, count, v);
 }
 
-GLvoid StubGLUniform1iv(GLint location, GLsizei count, const GLint* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform1iv(GLint location,
+                                            GLsizei count,
+                                            const GLint* v) {
   glUniform1iv(location, count, v);
 }
 
-GLvoid StubGLUniform2f(GLint location, GLfloat v0, GLfloat v1) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform2f(GLint location,
+                                           GLfloat v0,
+                                           GLfloat v1) {
   glUniform2f(location, v0, v1);
 }
 
-GLvoid StubGLUniform2i(GLint location, GLint v0, GLint v1) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform2i(GLint location, GLint v0, GLint v1) {
   glUniform2i(location, v0, v1);
 }
 
-GLvoid StubGLUniform2fv(GLint location, GLsizei count, const GLfloat* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform2fv(GLint location,
+                                            GLsizei count,
+                                            const GLfloat* v) {
   glUniform2fv(location, count, v);
 }
 
-GLvoid StubGLUniform2iv(GLint location, GLsizei count, const GLint* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform2iv(GLint location,
+                                            GLsizei count,
+                                            const GLint* v) {
   glUniform2iv(location, count, v);
 }
 
-GLvoid StubGLUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform3f(GLint location,
+                                           GLfloat v0,
+                                           GLfloat v1,
+                                           GLfloat v2) {
   glUniform3f(location, v0, v1, v2);
 }
 
-GLvoid StubGLUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform3i(GLint location,
+                                           GLint v0,
+                                           GLint v1,
+                                           GLint v2) {
   glUniform3i(location, v0, v1, v2);
 }
 
-GLvoid StubGLUniform3fv(GLint location, GLsizei count, const GLfloat* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform3fv(GLint location,
+                                            GLsizei count,
+                                            const GLfloat* v) {
   glUniform3fv(location, count, v);
 }
 
-GLvoid StubGLUniform3iv(GLint location, GLsizei count, const GLint* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform3iv(GLint location,
+                                            GLsizei count,
+                                            const GLint* v) {
   glUniform3iv(location, count, v);
 }
 
-GLvoid StubGLUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
-                       GLfloat v3) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform4f(GLint location,
+                                           GLfloat v0,
+                                           GLfloat v1,
+                                           GLfloat v2,
+                                           GLfloat v3) {
   glUniform4f(location, v0, v1, v2, v3);
 }
 
-GLvoid StubGLUniform4i(GLint location, GLint v0, GLint v1, GLint v2,
-                       GLint v3) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
   glUniform4i(location, v0, v1, v2, v3);
 }
 
-GLvoid StubGLUniform4fv(GLint location, GLsizei count, const GLfloat* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform4fv(GLint location,
+                                            GLsizei count,
+                                            const GLfloat* v) {
   glUniform4fv(location, count, v);
 }
 
-GLvoid StubGLUniform4iv(GLint location, GLsizei count, const GLint* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform4iv(GLint location,
+                                            GLsizei count,
+                                            const GLint* v) {
   glUniform4iv(location, count, v);
 }
 
-GLvoid StubGLUniformMatrix2fv(GLint location, GLsizei count,
-                              GLboolean transpose, const GLfloat* value) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniformMatrix2fv(GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat* value) {
   glUniformMatrix2fv(location, count, transpose, value);
 }
 
-GLvoid StubGLUniformMatrix3fv(GLint location, GLsizei count,
-                              GLboolean transpose, const GLfloat* value) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniformMatrix3fv(GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat* value) {
   glUniformMatrix3fv(location, count, transpose, value);
 }
 
-GLvoid StubGLUniformMatrix4fv(GLint location, GLsizei count,
-                              GLboolean transpose, const GLfloat* value) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniformMatrix4fv(GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat* value) {
   glUniformMatrix4fv(location, count, transpose, value);
 }
 
-GLboolean StubGLUnmapBuffer(GLenum target) {
+GLboolean GR_GL_FUNCTION_TYPE StubGLUnmapBuffer(GLenum target) {
   return glUnmapBuffer(target);
 }
 
-GLvoid StubGLUseProgram(GLuint program) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUseProgram(GLuint program) {
   glUseProgram(program);
 }
 
-GLvoid StubGLVertexAttrib1f(GLuint indx, const GLfloat value) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttrib1f(GLuint indx,
+                                                const GLfloat value) {
   glVertexAttrib1f(indx, value);
 }
 
-GLvoid StubGLVertexAttrib2fv(GLuint indx, const GLfloat* values) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttrib2fv(GLuint indx,
+                                                 const GLfloat* values) {
   glVertexAttrib2fv(indx, values);
 }
 
-GLvoid StubGLVertexAttrib3fv(GLuint indx, const GLfloat* values) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttrib3fv(GLuint indx,
+                                                 const GLfloat* values) {
   glVertexAttrib3fv(indx, values);
 }
 
-GLvoid StubGLVertexAttrib4fv(GLuint indx, const GLfloat* values) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttrib4fv(GLuint indx,
+                                                 const GLfloat* values) {
   glVertexAttrib4fv(indx, values);
 }
 
-GLvoid StubGLVertexAttribPointer(GLuint indx, GLint size, GLenum type,
-                                 GLboolean normalized, GLsizei stride,
-                                 const void* ptr) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttribPointer(GLuint indx,
+                                                     GLint size,
+                                                     GLenum type,
+                                                     GLboolean normalized,
+                                                     GLsizei stride,
+                                                     const void* ptr) {
   glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 }
 
-GLvoid StubGLViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLViewport(GLint x,
+                                          GLint y,
+                                          GLsizei width,
+                                          GLsizei height) {
   glViewport(x, y, width, height);
 }
 
-GLint StubGLGetProgramResourceLocation(GLuint program,
-                                       GLenum programInterface,
-                                       const char* name) {
+GLint GR_GL_FUNCTION_TYPE
+StubGLGetProgramResourceLocation(GLuint program,
+                                 GLenum programInterface,
+                                 const char* name) {
   return glGetProgramResourceLocation(program, programInterface, name);
 }
 
diff --git a/chromium/ui/gl/gl_context.cc b/chromium/ui/gl/gl_context.cc
index 1049bfdba3a..ada2127d507 100644
--- a/chromium/ui/gl/gl_context.cc
+++ b/chromium/ui/gl/gl_context.cc
@@ -85,22 +85,7 @@ void GLContext::SetUnbindFboOnMakeCurrent() {
 
 std::string GLContext::GetExtensions() {
   DCHECK(IsCurrent(nullptr));
-  if (gfx::GetGLImplementation() !=
-      gfx::kGLImplementationDesktopGLCoreProfile) {
-    const char* ext = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
-    return std::string(ext ? ext : "");
-  }
-
-  std::vector<std::string> exts;
-  GLint num_extensions = 0;
-  glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
-  for (GLint i = 0; i < num_extensions; ++i) {
-    const char* extension = reinterpret_cast<const char*>(
-        glGetStringi(GL_EXTENSIONS, i));
-    DCHECK(extension != nullptr);
-    exts.push_back(extension);
-  }
-  return JoinString(exts, " ");
+  return GetGLExtensionsFromCurrentContext();
 }
 
 std::string GLContext::GetGLVersion() {
diff --git a/chromium/ui/gl/gl_context.h b/chromium/ui/gl/gl_context.h
index 95986613e0b..d391deb0679 100644
--- a/chromium/ui/gl/gl_context.h
+++ b/chromium/ui/gl/gl_context.h
@@ -42,9 +42,6 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
   virtual bool Initialize(
       GLSurface* compatible_surface, GpuPreference gpu_preference) = 0;
 
-  // Destroys the GL context.
-  virtual void Destroy() = 0;
-
   // Makes the GL context and a surface current on the current thread.
   virtual bool MakeCurrent(GLSurface* surface) = 0;
 
diff --git a/chromium/ui/gl/gl_context_android.cc b/chromium/ui/gl/gl_context_android.cc
index 8786a0d4d5b..ebf1dda6b13 100644
--- a/chromium/ui/gl/gl_context_android.cc
+++ b/chromium/ui/gl/gl_context_android.cc
@@ -28,7 +28,6 @@ class GLNonOwnedContext : public GLContextReal {
   // Implement GLContext.
   bool Initialize(GLSurface* compatible_surface,
                   GpuPreference gpu_preference) override;
-  void Destroy() override {}
   bool MakeCurrent(GLSurface* surface) override;
   void ReleaseCurrent(GLSurface* surface) override {}
   bool IsCurrent(GLSurface* surface) override { return true; }
@@ -40,9 +39,9 @@ class GLNonOwnedContext : public GLContextReal {
   ~GLNonOwnedContext() override {}
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(GLNonOwnedContext);
-
   EGLDisplay display_;
+
+  DISALLOW_COPY_AND_ASSIGN(GLNonOwnedContext);
 };
 
 GLNonOwnedContext::GLNonOwnedContext(GLShareGroup* share_group)
diff --git a/chromium/ui/gl/gl_context_cgl.cc b/chromium/ui/gl/gl_context_cgl.cc
index e2e4af68243..6de014ecde9 100644
--- a/chromium/ui/gl/gl_context_cgl.cc
+++ b/chromium/ui/gl/gl_context_cgl.cc
@@ -80,7 +80,7 @@ GLContextCGL::GLContextCGL(GLShareGroup* share_group)
     discrete_pixelformat_(nullptr),
     screen_(-1),
     renderer_id_(-1),
-    safe_to_force_gpu_switch_(false) {
+    safe_to_force_gpu_switch_(true) {
 }
 
 bool GLContextCGL::Initialize(GLSurface* compatible_surface,
@@ -126,6 +126,11 @@ bool GLContextCGL::Initialize(GLSurface* compatible_surface,
   }
 
   gpu_preference_ = gpu_preference;
+  // Contexts that prefer integrated gpu are known to use only the subset of GL
+  // that can be safely migrated between the iGPU and the dGPU. Mark those
+  // contexts as safe to forcibly transition between the GPUs by default.
+  // http://crbug.com/180876, http://crbug.com/227228
+  safe_to_force_gpu_switch_ = gpu_preference == PreferIntegratedGpu;
   return true;
 }
 
diff --git a/chromium/ui/gl/gl_context_cgl.h b/chromium/ui/gl/gl_context_cgl.h
index 88813b39cc1..2c019988a23 100644
--- a/chromium/ui/gl/gl_context_cgl.h
+++ b/chromium/ui/gl/gl_context_cgl.h
@@ -21,7 +21,6 @@ class GLContextCGL : public GLContextReal {
   // Implement GLContext.
   bool Initialize(GLSurface* compatible_surface,
                   GpuPreference gpu_preference) override;
-  void Destroy() override;
   bool MakeCurrent(GLSurface* surface) override;
   void ReleaseCurrent(GLSurface* surface) override;
   bool IsCurrent(GLSurface* surface) override;
@@ -35,6 +34,7 @@ class GLContextCGL : public GLContextReal {
   ~GLContextCGL() override;
 
  private:
+  void Destroy();
   GpuPreference GetGpuPreference();
 
   void* context_;
diff --git a/chromium/ui/gl/gl_context_egl.h b/chromium/ui/gl/gl_context_egl.h
index 39b26d0c319..0d46723538e 100644
--- a/chromium/ui/gl/gl_context_egl.h
+++ b/chromium/ui/gl/gl_context_egl.h
@@ -26,7 +26,6 @@ class GLContextEGL : public GLContextReal {
   // Implement GLContext.
   bool Initialize(GLSurface* compatible_surface,
                   GpuPreference gpu_preference) override;
-  void Destroy() override;
   bool MakeCurrent(GLSurface* surface) override;
   void ReleaseCurrent(GLSurface* surface) override;
   bool IsCurrent(GLSurface* surface) override;
@@ -41,6 +40,8 @@ class GLContextEGL : public GLContextReal {
   ~GLContextEGL() override;
 
  private:
+  void Destroy();
+
   EGLContext context_;
   EGLDisplay display_;
   EGLConfig config_;
diff --git a/chromium/ui/gl/gl_context_glx.cc b/chromium/ui/gl/gl_context_glx.cc
index 9c4bb5f41e1..a8711a8fd79 100644
--- a/chromium/ui/gl/gl_context_glx.cc
+++ b/chromium/ui/gl/gl_context_glx.cc
@@ -10,6 +10,7 @@ extern "C" {
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/GL/glextchromium.h"
 #include "ui/gl/gl_bindings.h"
@@ -198,7 +199,8 @@ bool GLContextGLX::GetTotalGpuMemory(size_t* bytes) {
   if (HasExtension("GL_NVX_gpu_memory_info")) {
     GLint kbytes = 0;
     glGetIntegerv(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &kbytes);
-    *bytes = 1024*kbytes;
+    *bytes =
+        base::saturated_cast<size_t>(1024u * static_cast<uint64_t>(kbytes));
     return true;
   }
   return false;
diff --git a/chromium/ui/gl/gl_context_glx.h b/chromium/ui/gl/gl_context_glx.h
index 6973542c0aa..ac93a5d64b4 100644
--- a/chromium/ui/gl/gl_context_glx.h
+++ b/chromium/ui/gl/gl_context_glx.h
@@ -26,7 +26,6 @@ class GL_EXPORT GLContextGLX : public GLContextReal {
   // Implement GLContext.
   bool Initialize(GLSurface* compatible_surface,
                   GpuPreference gpu_preference) override;
-  void Destroy() override;
   bool MakeCurrent(GLSurface* surface) override;
   void ReleaseCurrent(GLSurface* surface) override;
   bool IsCurrent(GLSurface* surface) override;
@@ -40,6 +39,8 @@ class GL_EXPORT GLContextGLX : public GLContextReal {
   ~GLContextGLX() override;
 
  private:
+  void Destroy();
+
   void* context_;
   XDisplay* display_;
 
diff --git a/chromium/ui/gl/gl_context_osmesa.h b/chromium/ui/gl/gl_context_osmesa.h
index dc82ad331c6..597e0143683 100644
--- a/chromium/ui/gl/gl_context_osmesa.h
+++ b/chromium/ui/gl/gl_context_osmesa.h
@@ -24,7 +24,6 @@ class GLContextOSMesa : public GLContextReal {
   // Implement GLContext.
   bool Initialize(GLSurface* compatible_surface,
                   GpuPreference gpu_preference) override;
-  void Destroy() override;
   bool MakeCurrent(GLSurface* surface) override;
   void ReleaseCurrent(GLSurface* surface) override;
   bool IsCurrent(GLSurface* surface) override;
@@ -35,6 +34,8 @@ class GLContextOSMesa : public GLContextReal {
   ~GLContextOSMesa() override;
 
  private:
+  void Destroy();
+
   OSMesaContext context_;
   bool is_released_;
 
diff --git a/chromium/ui/gl/gl_context_stub.cc b/chromium/ui/gl/gl_context_stub.cc
index aed365923f7..2304585bae6 100644
--- a/chromium/ui/gl/gl_context_stub.cc
+++ b/chromium/ui/gl/gl_context_stub.cc
@@ -13,8 +13,6 @@ bool GLContextStub::Initialize(
   return true;
 }
 
-void GLContextStub::Destroy() {}
-
 bool GLContextStub::MakeCurrent(GLSurface* surface) {
   SetCurrent(surface);
   SetRealGLApi();
diff --git a/chromium/ui/gl/gl_context_stub.h b/chromium/ui/gl/gl_context_stub.h
index b4eef932802..811f9082b86 100644
--- a/chromium/ui/gl/gl_context_stub.h
+++ b/chromium/ui/gl/gl_context_stub.h
@@ -17,7 +17,6 @@ class GL_EXPORT GLContextStub : public GLContextReal {
   // Implement GLContext.
   bool Initialize(GLSurface* compatible_surface,
                   GpuPreference gpu_preference) override;
-  void Destroy() override;
   bool MakeCurrent(GLSurface* surface) override;
   void ReleaseCurrent(GLSurface* surface) override;
   bool IsCurrent(GLSurface* surface) override;
diff --git a/chromium/ui/gl/gl_context_wgl.h b/chromium/ui/gl/gl_context_wgl.h
index ff0aae0d96f..21b38403296 100644
--- a/chromium/ui/gl/gl_context_wgl.h
+++ b/chromium/ui/gl/gl_context_wgl.h
@@ -22,7 +22,6 @@ class GLContextWGL : public GLContextReal {
   // Implement GLContext.
   bool Initialize(GLSurface* compatible_surface,
                   GpuPreference gpu_preference) override;
-  void Destroy() override;
   bool MakeCurrent(GLSurface* surface) override;
   void ReleaseCurrent(GLSurface* surface) override;
   bool IsCurrent(GLSurface* surface) override;
@@ -32,6 +31,7 @@ class GLContextWGL : public GLContextReal {
 
  private:
   ~GLContextWGL() override;
+  void Destroy();
 
   HGLRC context_;
 
diff --git a/chromium/ui/gl/gl_enums_implementation_autogen.h b/chromium/ui/gl/gl_enums_implementation_autogen.h
index 9bd294ec5d6..de370dac666 100644
--- a/chromium/ui/gl/gl_enums_implementation_autogen.h
+++ b/chromium/ui/gl/gl_enums_implementation_autogen.h
@@ -10,4436 +10,3388 @@
 
 static const GLEnums::EnumToString enum_to_string_table[] = {
     {
-     0x8D77,
-     "GL_RGB16UI",
+        0x8D77, "GL_RGB16UI",
     },
     {
-     0x8D76,
-     "GL_RGBA16UI",
+        0x8D76, "GL_RGBA16UI",
     },
     {
-     0x9260,
-     "GL_GCCSO_SHADER_BINARY_FJ",
+        0x9260, "GL_GCCSO_SHADER_BINARY_FJ",
     },
     {
-     0x9009,
-     "GL_TEXTURE_CUBE_MAP_ARRAY_EXT",
+        0x9009, "GL_TEXTURE_CUBE_MAP_ARRAY_EXT",
     },
     {
-     0x8D71,
-     "GL_RGB32UI",
+        0x8D71, "GL_RGB32UI",
     },
     {
-     0x8D70,
-     "GL_RGBA32UI",
+        0x8D70, "GL_RGBA32UI",
     },
     {
-     0x8C76,
-     "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH",
+        0x8C76, "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH",
     },
     {
-     0x8825,
-     "GL_DRAW_BUFFER0_EXT",
+        0x8825, "GL_DRAW_BUFFER0_EXT",
     },
     {
-     0x8D94,
-     "GL_RED_INTEGER",
+        0x8D94, "GL_RED_INTEGER",
     },
     {
-     0x0BC1,
-     "GL_ALPHA_TEST_FUNC_QCOM",
+        0x0BC1, "GL_ALPHA_TEST_FUNC_QCOM",
     },
     {
-     0x884C,
-     "GL_TEXTURE_COMPARE_MODE_EXT",
+        0x884C, "GL_TEXTURE_COMPARE_MODE_EXT",
     },
     {
-     0x0BC2,
-     "GL_ALPHA_TEST_REF_QCOM",
+        0x0BC2, "GL_ALPHA_TEST_REF_QCOM",
     },
     {
-     0x78EF,
-     "GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
+        0x78EF, "GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
     },
     {
-     0x884D,
-     "GL_TEXTURE_COMPARE_FUNC_EXT",
+        0x884D, "GL_TEXTURE_COMPARE_FUNC_EXT",
     },
     {
-     0x884E,
-     "GL_COMPARE_REF_TO_TEXTURE_EXT",
+        0x884E, "GL_COMPARE_REF_TO_TEXTURE_EXT",
     },
     {
-     0x8E76,
-     "GL_TESS_GEN_MODE_EXT",
+        0x8E76, "GL_TESS_GEN_MODE_EXT",
     },
     {
-     0x8E77,
-     "GL_TESS_GEN_SPACING_EXT",
+        0x8E77, "GL_TESS_GEN_SPACING_EXT",
     },
     {
-     0x000D,
-     "GL_TRIANGLE_STRIP_ADJACENCY_EXT",
+        0x000D, "GL_TRIANGLE_STRIP_ADJACENCY_EXT",
     },
     {
-     0x000E,
-     "GL_PATCHES_EXT",
+        0x000E, "GL_PATCHES_EXT",
     },
     {
-     0x000B,
-     "GL_LINE_STRIP_ADJACENCY_EXT",
+        0x000B, "GL_LINE_STRIP_ADJACENCY_EXT",
     },
     {
-     0x000C,
-     "GL_TRIANGLES_ADJACENCY_EXT",
+        0x000C, "GL_TRIANGLES_ADJACENCY_EXT",
     },
     {
-     0x000A,
-     "GL_LINES_ADJACENCY_EXT",
+        0x000A, "GL_LINES_ADJACENCY_EXT",
     },
     {
-     0x92CF,
-     "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT",
+        0x8DCA, "GL_INT_SAMPLER_2D",
     },
     {
-     0x93A1,
-     "GL_BGRA8_EXT",
+        0x92CF, "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT",
     },
     {
-     0x813C,
-     "GL_TEXTURE_BASE_LEVEL",
+        0x93A1, "GL_BGRA8_EXT",
     },
     {
-     0,
-     "GL_FALSE",
+        0x813C, "GL_TEXTURE_BASE_LEVEL",
     },
     {
-     0x00400000,
-     "GL_STENCIL_BUFFER_BIT6_QCOM",
+        0, "GL_FALSE",
     },
     {
-     0x9500,
-     "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL",
+        0x00400000, "GL_STENCIL_BUFFER_BIT6_QCOM",
     },
     {
-     0x78F2,
-     "GL_SCANOUT_CHROMIUM",
+        0x9500, "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL",
     },
     {
-     0x9138,
-     "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG",
+        0x78F2, "GL_SCANOUT_CHROMIUM",
     },
     {
-     0x8FC4,
-     "GL_SHADER_BINARY_VIV",
+        0x9138, "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG",
     },
     {
-     0x9130,
-     "GL_SGX_PROGRAM_BINARY_IMG",
+        0x8FC4, "GL_SHADER_BINARY_VIV",
     },
     {
-     0x9133,
-     "GL_RENDERBUFFER_SAMPLES_IMG",
+        0x9130, "GL_SGX_PROGRAM_BINARY_IMG",
     },
     {
-     0x82E0,
-     "GL_BUFFER_KHR",
+        0x9133, "GL_RENDERBUFFER_SAMPLES_IMG",
     },
     {
-     0x9135,
-     "GL_MAX_SAMPLES_IMG",
+        0x82E0, "GL_BUFFER_KHR",
     },
     {
-     0x9134,
-     "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG",
+        0x9135, "GL_MAX_SAMPLES_IMG",
     },
     {
-     0x9137,
-     "GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG",
+        0x9134, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG",
     },
     {
-     0x9136,
-     "GL_TEXTURE_SAMPLES_IMG",
+        0x9137, "GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG",
     },
     {
-     0x8D88,
-     "GL_RGBA16I",
+        0x9136, "GL_TEXTURE_SAMPLES_IMG",
     },
     {
-     0x8D89,
-     "GL_RGB16I",
+        0x8D88, "GL_RGBA16I",
     },
     {
-     0x00000020,
-     "GL_COLOR_BUFFER_BIT5_QCOM",
+        0x8D89, "GL_RGB16I",
     },
     {
-     0x0008,
-     "GL_MAP_INVALIDATE_BUFFER_BIT_EXT",
+        0x00000020, "GL_COLOR_BUFFER_BIT5_QCOM",
     },
     {
-     0x0BC0,
-     "GL_ALPHA_TEST_QCOM",
+        0x0008, "GL_MAP_INVALIDATE_BUFFER_BIT_EXT",
     },
     {
-     0x0006,
-     "GL_TRIANGLE_FAN",
+        0x0BC0, "GL_ALPHA_TEST_QCOM",
     },
     {
-     0x0007,
-     "GL_QUADS_EXT",
+        0x0006, "GL_TRIANGLE_FAN",
     },
     {
-     0x0004,
-     "GL_TRIANGLES",
+        0x0007, "GL_QUADS_EXT",
     },
     {
-     0x0005,
-     "GL_TRIANGLE_STRIP",
+        0x0004, "GL_TRIANGLES",
     },
     {
-     0x0002,
-     "GL_LINE_LOOP",
+        0x0005, "GL_TRIANGLE_STRIP",
     },
     {
-     0x0003,
-     "GL_LINE_STRIP",
+        0x0002, "GL_LINE_LOOP",
     },
     {
-     0x0000,
-     "GL_POINTS",
+        0x0003, "GL_LINE_STRIP",
     },
     {
-     0x0001,
-     "GL_LINES",
+        0x0000, "GL_POINTS",
     },
     {
-     0x8D7D,
-     "GL_RGB8UI",
+        0x0001, "GL_LINES",
     },
     {
-     0x93F0,
-     "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG",
+        0x8D7D, "GL_RGB8UI",
     },
     {
-     0x93F1,
-     "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG",
+        0x93F0, "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG",
     },
     {
-     0x0D04,
-     "GL_PACK_SKIP_PIXELS",
+        0x93F1, "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG",
     },
     {
-     0x900E,
-     "GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT",
+        0x0D04, "GL_PACK_SKIP_PIXELS",
     },
     {
-     0x900D,
-     "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT",
+        0x900E, "GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT",
     },
     {
-     0x8C7F,
-     "GL_TRANSFORM_FEEDBACK_BUFFER_MODE",
+        0x900D, "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT",
     },
     {
-     0x900F,
-     "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT",
+        0x8C7F, "GL_TRANSFORM_FEEDBACK_BUFFER_MODE",
     },
     {
-     0x900A,
-     "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT",
+        0x900F, "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT",
     },
     {
-     0x900C,
-     "GL_SAMPLER_CUBE_MAP_ARRAY_EXT",
+        0x900A, "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT",
     },
     {
-     0x88B8,
-     "GL_READ_ONLY",
+        0x900C, "GL_SAMPLER_CUBE_MAP_ARRAY_EXT",
     },
     {
-     0x88B9,
-     "GL_WRITE_ONLY_OES",
+        0x88B8, "GL_READ_ONLY",
     },
     {
-     0x8211,
-     "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT",
+        0x88B9, "GL_WRITE_ONLY_OES",
     },
     {
-     0x8210,
-     "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT",
+        0x8211, "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT",
     },
     {
-     0x8741,
-     "GL_PROGRAM_BINARY_LENGTH_OES",
+        0x8210, "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT",
     },
     {
-     0x8740,
-     "GL_Z400_BINARY_AMD",
+        0x8741, "GL_PROGRAM_BINARY_LENGTH_OES",
     },
     {
-     0x8215,
-     "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE",
+        0x8740, "GL_Z400_BINARY_AMD",
     },
     {
-     0x8C4D,
-     "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV",
+        0x8215, "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE",
     },
     {
-     0x8192,
-     "GL_GENERATE_MIPMAP_HINT",
+        0x8C4D, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV",
     },
     {
-     0x8E79,
-     "GL_TESS_GEN_POINT_MODE_EXT",
+        0x8192, "GL_GENERATE_MIPMAP_HINT",
     },
     {
-     0x8A54,
-     "GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT",
+        0x8E79, "GL_TESS_GEN_POINT_MODE_EXT",
     },
     {
-     0x8A55,
-     "GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT",
+        0x8A54, "GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT",
     },
     {
-     0x8A56,
-     "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT",
+        0x8A55, "GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT",
     },
     {
-     0x8A57,
-     "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT",
+        0x8A56, "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT",
     },
     {
-     0x8A51,
-     "GL_RGB_RAW_422_APPLE",
+        0x8A57, "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT",
     },
     {
-     0x87F9,
-     "GL_3DC_X_AMD",
+        0x8A51, "GL_RGB_RAW_422_APPLE",
     },
     {
-     0x8A53,
-     "GL_SYNC_OBJECT_APPLE",
+        0x87F9, "GL_3DC_X_AMD",
     },
     {
-     0x8DF8,
-     "GL_SHADER_BINARY_FORMATS",
+        0x8A53, "GL_SYNC_OBJECT_APPLE",
     },
     {
-     0x8DF9,
-     "GL_NUM_SHADER_BINARY_FORMATS",
+        0x8DF8, "GL_SHADER_BINARY_FORMATS",
     },
     {
-     0x826D,
-     "GL_DEBUG_GROUP_STACK_DEPTH_KHR",
+        0x8DF9, "GL_NUM_SHADER_BINARY_FORMATS",
     },
     {
-     0x8E75,
-     "GL_TESS_CONTROL_OUTPUT_VERTICES_EXT",
+        0x826D, "GL_DEBUG_GROUP_STACK_DEPTH_KHR",
     },
     {
-     0x826B,
-     "GL_DEBUG_SEVERITY_NOTIFICATION_KHR",
+        0x8E75, "GL_TESS_CONTROL_OUTPUT_VERTICES_EXT",
     },
     {
-     0x826C,
-     "GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR",
+        0x826B, "GL_DEBUG_SEVERITY_NOTIFICATION_KHR",
     },
     {
-     0x8B59,
-     "GL_BOOL_VEC4",
+        0x826C, "GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR",
     },
     {
-     0x826A,
-     "GL_DEBUG_TYPE_POP_GROUP_KHR",
+        0x8B59, "GL_BOOL_VEC4",
     },
     {
-     0x8B57,
-     "GL_BOOL_VEC2",
+        0x826A, "GL_DEBUG_TYPE_POP_GROUP_KHR",
     },
     {
-     0x8DF1,
-     "GL_MEDIUM_FLOAT",
+        0x8B57, "GL_BOOL_VEC2",
     },
     {
-     0x8B55,
-     "GL_INT_VEC4",
+        0x8DF1, "GL_MEDIUM_FLOAT",
     },
     {
-     0x8B54,
-     "GL_INT_VEC3",
+        0x8B55, "GL_INT_VEC4",
     },
     {
-     0x8DF4,
-     "GL_MEDIUM_INT",
+        0x8B54, "GL_INT_VEC3",
     },
     {
-     0x8DF5,
-     "GL_HIGH_INT",
+        0x8DF4, "GL_MEDIUM_INT",
     },
     {
-     0x8B51,
-     "GL_FLOAT_VEC3",
+        0x8DF5, "GL_HIGH_INT",
     },
     {
-     0x8B50,
-     "GL_FLOAT_VEC2",
+        0x8B51, "GL_FLOAT_VEC3",
     },
     {
-     0x806D,
-     "GL_UNPACK_SKIP_IMAGES",
+        0x8B50, "GL_FLOAT_VEC2",
     },
     {
-     0x806E,
-     "GL_UNPACK_IMAGE_HEIGHT",
+        0x806D, "GL_UNPACK_SKIP_IMAGES",
     },
     {
-     0x806F,
-     "GL_TEXTURE_3D_OES",
+        0x806E, "GL_UNPACK_IMAGE_HEIGHT",
     },
     {
-     0x92E7,
-     "GL_IS_PER_PATCH_EXT",
+        0x806F, "GL_TEXTURE_3D_OES",
     },
     {
-     0x92E0,
-     "GL_DEBUG_OUTPUT_KHR",
+        0x92E7, "GL_IS_PER_PATCH_EXT",
     },
     {
-     0x806A,
-     "GL_TEXTURE_BINDING_3D_OES",
+        0x92E0, "GL_DEBUG_OUTPUT_KHR",
     },
     {
-     0x8D8E,
-     "GL_RGBA8I",
+        0x806A, "GL_TEXTURE_BINDING_3D_OES",
     },
     {
-     0x8CE3,
-     "GL_COLOR_ATTACHMENT3_EXT",
+        0x8D8E, "GL_RGBA8I",
     },
     {
-     0x9274,
-     "GL_COMPRESSED_RGB8_ETC2",
+        0x8CE3, "GL_COLOR_ATTACHMENT3_EXT",
     },
     {
-     0x1904,
-     "GL_GREEN_NV",
+        0x9274, "GL_COMPRESSED_RGB8_ETC2",
     },
     {
-     0x928D,
-     "GL_DST_OUT_NV",
+        0x1904, "GL_GREEN_NV",
     },
     {
-     0x8069,
-     "GL_TEXTURE_BINDING_2D",
+        0x928D, "GL_DST_OUT_NV",
     },
     {
-     0x8A2E,
-     "GL_MAX_COMBINED_UNIFORM_BLOCKS",
+        0x8069, "GL_TEXTURE_BINDING_2D",
     },
     {
-     0x8F96,
-     "GL_RGB8_SNORM",
+        0x8A2E, "GL_MAX_COMBINED_UNIFORM_BLOCKS",
     },
     {
-     0x8F95,
-     "GL_RG8_SNORM",
+        0x8F96, "GL_RGB8_SNORM",
     },
     {
-     0x8260,
-     "GL_UNDEFINED_VERTEX_EXT",
+        0x8F95, "GL_RG8_SNORM",
     },
     {
-     0x8261,
-     "GL_NO_RESET_NOTIFICATION_KHR",
+        0x8260, "GL_UNDEFINED_VERTEX_EXT",
     },
     {
-     0x0D02,
-     "GL_PACK_ROW_LENGTH",
+        0x8261, "GL_NO_RESET_NOTIFICATION_KHR",
     },
     {
-     0x8DFA,
-     "GL_SHADER_COMPILER",
+        0x0D02, "GL_PACK_ROW_LENGTH",
     },
     {
-     0x8DFB,
-     "GL_MAX_VERTEX_UNIFORM_VECTORS",
+        0x8DFA, "GL_SHADER_COMPILER",
     },
     {
-     0x8DFC,
-     "GL_MAX_VARYING_VECTORS",
+        0x8DFB, "GL_MAX_VERTEX_UNIFORM_VECTORS",
     },
     {
-     0x8B5C,
-     "GL_FLOAT_MAT4",
+        0x8DFC, "GL_MAX_VARYING_VECTORS",
     },
     {
-     0x8B5B,
-     "GL_FLOAT_MAT3",
+        0x8B5C, "GL_FLOAT_MAT4",
     },
     {
-     0x8268,
-     "GL_DEBUG_TYPE_MARKER_KHR",
+        0x8B5B, "GL_FLOAT_MAT3",
     },
     {
-     0x8269,
-     "GL_DEBUG_TYPE_PUSH_GROUP_KHR",
+        0x8268, "GL_DEBUG_TYPE_MARKER_KHR",
     },
     {
-     0x8A43,
-     "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES",
+        0x8269, "GL_DEBUG_TYPE_PUSH_GROUP_KHR",
     },
     {
-     0x1905,
-     "GL_BLUE_NV",
+        0x8A43, "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES",
     },
     {
-     0x87FF,
-     "GL_PROGRAM_BINARY_FORMATS_OES",
+        0x1905, "GL_BLUE_NV",
     },
     {
-     0x87FE,
-     "GL_NUM_PROGRAM_BINARY_FORMATS_OES",
+        0x87FF, "GL_PROGRAM_BINARY_FORMATS_OES",
     },
     {
-     0x8A41,
-     "GL_UNIFORM_BLOCK_NAME_LENGTH",
+        0x87FE, "GL_NUM_PROGRAM_BINARY_FORMATS_OES",
     },
     {
-     0x2600,
-     "GL_NEAREST",
+        0x8A2D, "GL_MAX_FRAGMENT_UNIFORM_BLOCKS",
     },
     {
-     0x2601,
-     "GL_LINEAR",
+        0x8A41, "GL_UNIFORM_BLOCK_NAME_LENGTH",
     },
     {
-     0x8C03,
-     "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG",
+        0x2600, "GL_NEAREST",
     },
     {
-     0x821B,
-     "GL_MAJOR_VERSION",
+        0x2601, "GL_LINEAR",
     },
     {
-     0x821A,
-     "GL_DEPTH_STENCIL_ATTACHMENT",
+        0x8C03, "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG",
     },
     {
-     0x8A40,
-     "GL_UNIFORM_BLOCK_DATA_SIZE",
+        0x821B, "GL_MAJOR_VERSION",
     },
     {
-     0x9242,
-     "GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM",
+        0x821A, "GL_DEPTH_STENCIL_ATTACHMENT",
     },
     {
-     0x821D,
-     "GL_NUM_EXTENSIONS",
+        0x8A40, "GL_UNIFORM_BLOCK_DATA_SIZE",
     },
     {
-     0x88BB,
-     "GL_BUFFER_ACCESS_OES",
+        0x821D, "GL_NUM_EXTENSIONS",
     },
     {
-     0x88BC,
-     "GL_BUFFER_MAPPED_OES",
+        0x88BB, "GL_BUFFER_ACCESS_OES",
     },
     {
-     0x88BD,
-     "GL_BUFFER_MAP_POINTER_OES",
+        0x88BC, "GL_BUFFER_MAPPED_OES",
     },
     {
-     0x88BF,
-     "GL_TIME_ELAPSED_EXT",
+        0x88BD, "GL_BUFFER_MAP_POINTER_OES",
     },
     {
-     0x8A46,
-     "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER",
+        0x88BF, "GL_TIME_ELAPSED_EXT",
     },
     {
-     0x6003,
-     "GL_GET_ERROR_QUERY_CHROMIUM",
+        0x8A46, "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER",
     },
     {
-     0x8F94,
-     "GL_R8_SNORM",
+        0x6003, "GL_GET_ERROR_QUERY_CHROMIUM",
     },
     {
-     0x0C10,
-     "GL_SCISSOR_BOX",
+        0x8F94, "GL_R8_SNORM",
     },
     {
-     0x0C11,
-     "GL_SCISSOR_TEST",
+        0x0C10, "GL_SCISSOR_BOX",
     },
     {
-     0x1700,
-     "GL_PATH_MODELVIEW_CHROMIUM",
+        0x0C11, "GL_SCISSOR_TEST",
     },
     {
-     0x80000000,
-     "GL_MULTISAMPLE_BUFFER_BIT7_QCOM",
+        0x1700, "GL_PATH_MODELVIEW_CHROMIUM",
     },
     {
-     0x94F8,
-     "GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL",
+        0x80000000, "GL_MULTISAMPLE_BUFFER_BIT7_QCOM",
     },
     {
-     0x8A48,
-     "GL_TEXTURE_SRGB_DECODE_EXT",
+        0x94F8, "GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL",
     },
     {
-     0x300E,
-     "GL_CONTEXT_LOST",
+        0x90a4, "GL_ROUND_CHROMIUM",
     },
     {
-     0x02000000,
-     "GL_MULTISAMPLE_BUFFER_BIT1_QCOM",
+        0x8A48, "GL_TEXTURE_SRGB_DECODE_EXT",
     },
     {
-     0x8C2F,
-     "GL_ANY_SAMPLES_PASSED_EXT",
+        0x300E, "GL_CONTEXT_LOST",
     },
     {
-     0x8BD2,
-     "GL_TEXTURE_WIDTH_QCOM",
+        0x90a3, "GL_SQUARE_CHROMIUM",
     },
     {
-     0x8C2D,
-     "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT",
+        0x02000000, "GL_MULTISAMPLE_BUFFER_BIT1_QCOM",
     },
     {
-     0x8C2C,
-     "GL_TEXTURE_BINDING_BUFFER_EXT",
+        0x8C2F, "GL_ANY_SAMPLES_PASSED_EXT",
     },
     {
-     0x8C2B,
-     "GL_MAX_TEXTURE_BUFFER_SIZE_EXT",
+        0x8BD2, "GL_TEXTURE_WIDTH_QCOM",
     },
     {
-     0x8C2A,
-     "GL_TEXTURE_BUFFER_EXT",
+        0x8C2D, "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT",
     },
     {
-     0x8BD7,
-     "GL_TEXTURE_TYPE_QCOM",
+        0x8C2C, "GL_TEXTURE_BINDING_BUFFER_EXT",
     },
     {
-     0x8B8D,
-     "GL_CURRENT_PROGRAM",
+        0x8C2B, "GL_MAX_TEXTURE_BUFFER_SIZE_EXT",
     },
     {
-     0x8BD9,
-     "GL_TEXTURE_NUM_LEVELS_QCOM",
+        0x8C2A, "GL_TEXTURE_BUFFER_EXT",
     },
     {
-     0x00200000,
-     "GL_STENCIL_BUFFER_BIT5_QCOM",
+        0x8BD7, "GL_TEXTURE_TYPE_QCOM",
     },
     {
-     0x8D9F,
-     "GL_INT_2_10_10_10_REV",
+        0x8B8D, "GL_CURRENT_PROGRAM",
     },
     {
-     0x8B8A,
-     "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH",
+        0x8BD9, "GL_TEXTURE_NUM_LEVELS_QCOM",
     },
     {
-     0x8B8B,
-     "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES",
+        0x00200000, "GL_STENCIL_BUFFER_BIT5_QCOM",
     },
     {
-     0x8B8C,
-     "GL_SHADING_LANGUAGE_VERSION",
+        0x8D9F, "GL_INT_2_10_10_10_REV",
     },
     {
-     0x8BDA,
-     "GL_TEXTURE_TARGET_QCOM",
+        0x8B8A, "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH",
     },
     {
-     0x8BDB,
-     "GL_TEXTURE_OBJECT_VALID_QCOM",
+        0x8B8B, "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES",
     },
     {
-     0x8BDC,
-     "GL_STATE_RESTORE",
+        0x8B8C, "GL_SHADING_LANGUAGE_VERSION",
     },
     {
-     0x8B88,
-     "GL_SHADER_SOURCE_LENGTH",
+        0x8BDA, "GL_TEXTURE_TARGET_QCOM",
     },
     {
-     0x8B89,
-     "GL_ACTIVE_ATTRIBUTES",
+        0x8BDB, "GL_TEXTURE_OBJECT_VALID_QCOM",
     },
     {
-     0x93C9,
-     "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES",
+        0x8BDC, "GL_STATE_RESTORE",
     },
     {
-     0x93C8,
-     "GL_COMPRESSED_RGBA_ASTC_6x6x5_OES",
+        0x8B88, "GL_SHADER_SOURCE_LENGTH",
     },
     {
-     0x8B84,
-     "GL_INFO_LOG_LENGTH",
+        0x8B89, "GL_ACTIVE_ATTRIBUTES",
     },
     {
-     0x8B85,
-     "GL_ATTACHED_SHADERS",
+        0x93C9, "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES",
     },
     {
-     0x8B86,
-     "GL_ACTIVE_UNIFORMS",
+        0x93C8, "GL_COMPRESSED_RGBA_ASTC_6x6x5_OES",
     },
     {
-     0x8B87,
-     "GL_ACTIVE_UNIFORM_MAX_LENGTH",
+        0x8B84, "GL_INFO_LOG_LENGTH",
     },
     {
-     0x8B80,
-     "GL_DELETE_STATUS",
+        0x8B85, "GL_ATTACHED_SHADERS",
     },
     {
-     0x8B81,
-     "GL_COMPILE_STATUS",
+        0x8B86, "GL_ACTIVE_UNIFORMS",
     },
     {
-     0x8B82,
-     "GL_LINK_STATUS",
+        0x8B87, "GL_ACTIVE_UNIFORM_MAX_LENGTH",
     },
     {
-     0x8B83,
-     "GL_VALIDATE_STATUS",
+        0x8B80, "GL_DELETE_STATUS",
     },
     {
-     0x78FA,
-     "GL_RGB_YUV_420_CHROMIUM",
+        0x8B81, "GL_COMPILE_STATUS",
     },
     {
-     0x8D48,
-     "GL_STENCIL_INDEX8",
+        0x8B82, "GL_LINK_STATUS",
     },
     {
-     0x8D46,
-     "GL_STENCIL_INDEX1_OES",
+        0x8B83, "GL_VALIDATE_STATUS",
     },
     {
-     0x8D47,
-     "GL_STENCIL_INDEX4_OES",
+        0x78FA, "GL_RGB_YUV_420_CHROMIUM",
     },
     {
-     0x8D44,
-     "GL_RENDERBUFFER_INTERNAL_FORMAT",
+        0x8D48, "GL_STENCIL_INDEX8",
     },
     {
-     0x00000100,
-     "GL_DEPTH_BUFFER_BIT",
+        0x8D46, "GL_STENCIL_INDEX1_OES",
     },
     {
-     0x8D42,
-     "GL_RENDERBUFFER_WIDTH",
+        0x8D47, "GL_STENCIL_INDEX4_OES",
     },
     {
-     0x8D43,
-     "GL_RENDERBUFFER_HEIGHT",
+        0x8D44, "GL_RENDERBUFFER_INTERNAL_FORMAT",
     },
     {
-     0x8D40,
-     "GL_FRAMEBUFFER",
+        0x00000100, "GL_DEPTH_BUFFER_BIT",
     },
     {
-     0x8D41,
-     "GL_RENDERBUFFER",
+        0x8D42, "GL_RENDERBUFFER_WIDTH",
     },
     {
-     0x8A3A,
-     "GL_UNIFORM_BLOCK_INDEX",
+        0x8D43, "GL_RENDERBUFFER_HEIGHT",
     },
     {
-     0x0BD0,
-     "GL_DITHER",
+        0x8D40, "GL_FRAMEBUFFER",
     },
     {
-     0x93D3,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR",
+        0x8D41, "GL_RENDERBUFFER",
     },
     {
-     0x9144,
-     "GL_MAX_DEBUG_LOGGED_MESSAGES_KHR",
+        0x90B7, "GL_PATH_STENCIL_FUNC_CHROMIUM",
     },
     {
-     0x1801,
-     "GL_DEPTH_EXT",
+        0x8A3A, "GL_UNIFORM_BLOCK_INDEX",
     },
     {
-     0x1800,
-     "GL_COLOR_EXT",
+        0x0BD0, "GL_DITHER",
     },
     {
-     0x1802,
-     "GL_STENCIL_EXT",
+        0x90B9, "GL_PATH_STENCIL_VALUE_MASK_CHROMIUM",
     },
     {
-     0x9288,
-     "GL_SRC_OVER_NV",
+        0x90B8, "GL_PATH_STENCIL_REF_CHROMIUM",
     },
     {
-     0x9120,
-     "GL_BUFFER_MAP_LENGTH",
+        0x93D3, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR",
     },
     {
-     0x0B21,
-     "GL_LINE_WIDTH",
+        0x1D00, "GL_FLAT_CHROMIUM",
     },
     {
-     0x9308,
-     "GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT",
+        0x9144, "GL_MAX_DEBUG_LOGGED_MESSAGES_KHR",
     },
     {
-     0x81A5,
-     "GL_DEPTH_COMPONENT16",
+        0x1801, "GL_DEPTH_EXT",
     },
     {
-     0x81A6,
-     "GL_DEPTH_COMPONENT24_OES",
+        0x1800, "GL_COLOR_EXT",
     },
     {
-     0x81A7,
-     "GL_DEPTH_COMPONENT32_OES",
+        0x1802, "GL_STENCIL_EXT",
     },
     {
-     0x88FD,
-     "GL_VERTEX_ATTRIB_ARRAY_INTEGER",
+        0x9288, "GL_SRC_OVER_NV",
     },
     {
-     0x88FE,
-     "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE",
+        0x9120, "GL_BUFFER_MAP_LENGTH",
     },
     {
-     0x88FF,
-     "GL_MAX_ARRAY_TEXTURE_LAYERS",
+        0x0B21, "GL_LINE_WIDTH",
     },
     {
-     0x8B6A,
-     "GL_FLOAT_MAT4x3_NV",
+        0x9308, "GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT",
     },
     {
-     0x93D0,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR",
+        0x81A5, "GL_DEPTH_COMPONENT16",
     },
     {
-     0x9143,
-     "GL_MAX_DEBUG_MESSAGE_LENGTH_KHR",
+        0x81A6, "GL_DEPTH_COMPONENT24_OES",
     },
     {
-     0x8DFD,
-     "GL_MAX_FRAGMENT_UNIFORM_VECTORS",
+        0x81A7, "GL_DEPTH_COMPONENT32_OES",
     },
     {
-     0x9145,
-     "GL_DEBUG_LOGGED_MESSAGES_KHR",
+        0x88FD, "GL_VERTEX_ATTRIB_ARRAY_INTEGER",
     },
     {
-     0x9146,
-     "GL_DEBUG_SEVERITY_HIGH_KHR",
+        0x88FE, "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE",
     },
     {
-     0x9147,
-     "GL_DEBUG_SEVERITY_MEDIUM_KHR",
+        0x88FF, "GL_MAX_ARRAY_TEXTURE_LAYERS",
     },
     {
-     0x9148,
-     "GL_DEBUG_SEVERITY_LOW_KHR",
+        0x8B6A, "GL_FLOAT_MAT4x3_NV",
     },
     {
-     0x8F63,
-     "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT",
+        0x93D0, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR",
     },
     {
-     0x8F60,
-     "GL_MALI_SHADER_BINARY_ARM",
+        0x9143, "GL_MAX_DEBUG_MESSAGE_LENGTH_KHR",
     },
     {
-     0x8F61,
-     "GL_MALI_PROGRAM_BINARY_ARM",
+        0x8DFD, "GL_MAX_FRAGMENT_UNIFORM_VECTORS",
     },
     {
-     0x8F66,
-     "GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM",
+        0x9145, "GL_DEBUG_LOGGED_MESSAGES_KHR",
     },
     {
-     0x8F67,
-     "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT",
+        0x9146, "GL_DEBUG_SEVERITY_HIGH_KHR",
     },
     {
-     0x8F64,
-     "GL_SHADER_PIXEL_LOCAL_STORAGE_EXT",
+        0x9147, "GL_DEBUG_SEVERITY_MEDIUM_KHR",
     },
     {
-     0x8F65,
-     "GL_FETCH_PER_SAMPLE_ARM",
+        0x9148, "GL_DEBUG_SEVERITY_LOW_KHR",
     },
     {
-     0x92D3,
-     "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT",
+        0x8F63, "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT",
     },
     {
-     0x87EE,
-     "GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD",
+        0x8F60, "GL_MALI_SHADER_BINARY_ARM",
     },
     {
-     0x822B,
-     "GL_RG8_EXT",
+        0x8F61, "GL_MALI_PROGRAM_BINARY_ARM",
     },
     {
-     0x822F,
-     "GL_RG16F_EXT",
+        0x8F66, "GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM",
     },
     {
-     0x822D,
-     "GL_R16F_EXT",
+        0x8F67, "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT",
     },
     {
-     0x822E,
-     "GL_R32F_EXT",
+        0x8F64, "GL_SHADER_PIXEL_LOCAL_STORAGE_EXT",
     },
     {
-     1,
-     "GL_ES_VERSION_2_0",
+        0x8F65, "GL_FETCH_PER_SAMPLE_ARM",
     },
     {
-     0x84F9,
-     "GL_DEPTH_STENCIL_OES",
+        0x92D3, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT",
     },
     {
-     0x82DB,
-     "GL_TEXTURE_VIEW_MIN_LEVEL_EXT",
+        0x87EE, "GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD",
     },
     {
-     0x8368,
-     "GL_UNSIGNED_INT_2_10_10_10_REV_EXT",
+        0x822B, "GL_RG8_EXT",
     },
     {
-     0x8819,
-     "GL_LUMINANCE_ALPHA32F_EXT",
+        0x822F, "GL_RG16F_EXT",
     },
     {
-     0x8818,
-     "GL_LUMINANCE32F_EXT",
+        0x822D, "GL_R16F_EXT",
     },
     {
-     0x82DF,
-     "GL_TEXTURE_IMMUTABLE_LEVELS",
+        0x822E, "GL_R32F_EXT",
     },
     {
-     0x8363,
-     "GL_UNSIGNED_SHORT_5_6_5",
+        1, "GL_ES_VERSION_2_0",
     },
     {
-     0x9051,
-     "GL_IMAGE_BUFFER_EXT",
+        0x84F9, "GL_DEPTH_STENCIL_OES",
     },
     {
-     0x84F2,
-     "GL_ALL_COMPLETED_NV",
+        0x82DB, "GL_TEXTURE_VIEW_MIN_LEVEL_EXT",
     },
     {
-     0x8E5A,
-     "GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT",
+        0x8368, "GL_UNSIGNED_INT_2_10_10_10_REV_EXT",
     },
     {
-     0x84F4,
-     "GL_FENCE_CONDITION_NV",
+        0x8819, "GL_LUMINANCE_ALPHA32F_EXT",
     },
     {
-     0x8366,
-     "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT",
+        0x8818, "GL_LUMINANCE32F_EXT",
     },
     {
-     0x8365,
-     "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT",
+        0x82DF, "GL_TEXTURE_IMMUTABLE_LEVELS",
     },
     {
-     0x84F7,
-     "GL_COMMANDS_COMPLETED_CHROMIUM",
+        0x8363, "GL_UNSIGNED_SHORT_5_6_5",
     },
     {
-     0x8F9C,
-     "GL_SIGNED_NORMALIZED",
+        0x9051, "GL_IMAGE_BUFFER_EXT",
     },
     {
-     0x92D5,
-     "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT",
+        0x84F2, "GL_ALL_COMPLETED_NV",
     },
     {
-     0x881E,
-     "GL_LUMINANCE16F_EXT",
+        0x8E5A, "GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT",
     },
     {
-     0x84FA,
-     "GL_UNSIGNED_INT_24_8_OES",
+        0x84F4, "GL_FENCE_CONDITION_NV",
     },
     {
-     0x92D4,
-     "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT",
+        0x8366, "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT",
     },
     {
-     0x881A,
-     "GL_RGBA16F_EXT",
+        0x8365, "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT",
     },
     {
-     0x84FE,
-     "GL_TEXTURE_MAX_ANISOTROPY_EXT",
+        0x84F7, "GL_COMMANDS_COMPLETED_CHROMIUM",
     },
     {
-     0x0901,
-     "GL_CCW",
+        0x8F9C, "GL_SIGNED_NORMALIZED",
     },
     {
-     0x0900,
-     "GL_CW",
+        0x92D5, "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT",
     },
     {
-     0x9317,
-     "GL_MAX_FRAMEBUFFER_LAYERS_EXT",
+        0x881E, "GL_LUMINANCE16F_EXT",
     },
     {
-     0x8229,
-     "GL_R8_EXT",
+        0x84FA, "GL_UNSIGNED_INT_24_8_OES",
     },
     {
-     0x8230,
-     "GL_RG32F_EXT",
+        0x92D4, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT",
     },
     {
-     0x9312,
-     "GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT",
+        0x881A, "GL_RGBA16F_EXT",
     },
     {
-     0x9283,
-     "GL_DISJOINT_NV",
+        0x84FE, "GL_TEXTURE_MAX_ANISOTROPY_EXT",
     },
     {
-     0x8221,
-     "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED",
+        0x0901, "GL_CCW",
     },
     {
-     0x8227,
-     "GL_RG_EXT",
+        0x0900, "GL_CW",
     },
     {
-     0x8B66,
-     "GL_FLOAT_MAT2x4_NV",
+        0x9317, "GL_MAX_FRAMEBUFFER_LAYERS_EXT",
     },
     {
-     0x8B67,
-     "GL_FLOAT_MAT3x2_NV",
+        0x8229, "GL_R8_EXT",
     },
     {
-     0x8E1E,
-     "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT",
+        0x8230, "GL_RG32F_EXT",
     },
     {
-     0x8B62,
-     "GL_SAMPLER_2D_SHADOW_EXT",
+        0x9312, "GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT",
     },
     {
-     0x8B63,
-     "GL_SAMPLER_2D_RECT_ARB",
+        0x9283, "GL_DISJOINT_NV",
     },
     {
-     0x8B60,
-     "GL_SAMPLER_CUBE",
+        0x8221, "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED",
     },
     {
-     0x00001000,
-     "GL_DEPTH_BUFFER_BIT4_QCOM",
+        0x8227, "GL_RG_EXT",
     },
     {
-     0x8B68,
-     "GL_FLOAT_MAT3x4_NV",
+        0x8B66, "GL_FLOAT_MAT2x4_NV",
     },
     {
-     0x83F0,
-     "GL_COMPRESSED_RGB_S3TC_DXT1_EXT",
+        0x8B67, "GL_FLOAT_MAT3x2_NV",
     },
     {
-     0x8D6A,
-     "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT",
+        0x8E1E, "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT",
     },
     {
-     0x00000080,
-     "GL_COLOR_BUFFER_BIT7_QCOM",
+        0x8B62, "GL_SAMPLER_2D_SHADOW_EXT",
     },
     {
-     0x88F0,
-     "GL_DEPTH24_STENCIL8_OES",
+        0x8B63, "GL_SAMPLER_2D_RECT_ARB",
     },
     {
-     0x8E1F,
-     "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT",
+        0x8B60, "GL_SAMPLER_CUBE",
     },
     {
-     0x80A0,
-     "GL_SAMPLE_COVERAGE",
+        0x00001000, "GL_DEPTH_BUFFER_BIT4_QCOM",
     },
     {
-     0x928F,
-     "GL_DST_ATOP_NV",
+        0x8B68, "GL_FLOAT_MAT3x4_NV",
     },
     {
-     0x8213,
-     "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE",
+        0x83F0, "GL_COMPRESSED_RGB_S3TC_DXT1_EXT",
     },
     {
-     0x80A9,
-     "GL_SAMPLES",
+        0x8D6A, "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT",
     },
     {
-     0x80A8,
-     "GL_SAMPLE_BUFFERS",
+        0x00000080, "GL_COLOR_BUFFER_BIT7_QCOM",
     },
     {
-     0x0D55,
-     "GL_ALPHA_BITS",
+        0x88F0, "GL_DEPTH24_STENCIL8_OES",
     },
     {
-     0x0D54,
-     "GL_BLUE_BITS",
+        0x8E1F, "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT",
     },
     {
-     0x0D57,
-     "GL_STENCIL_BITS",
+        0x80A0, "GL_SAMPLE_COVERAGE",
     },
     {
-     0x0D56,
-     "GL_DEPTH_BITS",
+        0x0C, "GL_CUBIC_CURVE_TO_CHROMIUM",
     },
     {
-     0x8CD5,
-     "GL_FRAMEBUFFER_COMPLETE",
+        0x928F, "GL_DST_ATOP_NV",
     },
     {
-     0x0D50,
-     "GL_SUBPIXEL_BITS",
+        0x8213, "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE",
     },
     {
-     0x0D53,
-     "GL_GREEN_BITS",
+        0x80A9, "GL_SAMPLES",
     },
     {
-     0x0D52,
-     "GL_RED_BITS",
+        0x80A8, "GL_SAMPLE_BUFFERS",
     },
     {
-     0x8037,
-     "GL_POLYGON_OFFSET_FILL",
+        0x0D55, "GL_ALPHA_BITS",
     },
     {
-     0x928C,
-     "GL_SRC_OUT_NV",
+        0x0D54, "GL_BLUE_BITS",
     },
     {
-     0x8034,
-     "GL_UNSIGNED_SHORT_5_5_5_1",
+        0x0D57, "GL_STENCIL_BITS",
     },
     {
-     0x8033,
-     "GL_UNSIGNED_SHORT_4_4_4_4",
+        0x0D56, "GL_DEPTH_BITS",
     },
     {
-     0x928B,
-     "GL_DST_IN_NV",
+        0x8CD5, "GL_FRAMEBUFFER_COMPLETE",
     },
     {
-     0x0305,
-     "GL_ONE_MINUS_DST_ALPHA",
+        0x0D50, "GL_SUBPIXEL_BITS",
     },
     {
-     0x0304,
-     "GL_DST_ALPHA",
+        0x0D53, "GL_GREEN_BITS",
     },
     {
-     0x0307,
-     "GL_ONE_MINUS_DST_COLOR",
+        0x0D52, "GL_RED_BITS",
     },
     {
-     0x0306,
-     "GL_DST_COLOR",
+        0x8037, "GL_POLYGON_OFFSET_FILL",
     },
     {
-     0x0301,
-     "GL_ONE_MINUS_SRC_COLOR",
+        0x928C, "GL_SRC_OUT_NV",
     },
     {
-     0x0300,
-     "GL_SRC_COLOR",
+        0x8034, "GL_UNSIGNED_SHORT_5_5_5_1",
     },
     {
-     0x0303,
-     "GL_ONE_MINUS_SRC_ALPHA",
+        0x8033, "GL_UNSIGNED_SHORT_4_4_4_4",
     },
     {
-     0x0302,
-     "GL_SRC_ALPHA",
+        0x928B, "GL_DST_IN_NV",
     },
     {
-     0x8212,
-     "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE",
+        0x0305, "GL_ONE_MINUS_DST_ALPHA",
     },
     {
-     0x0308,
-     "GL_SRC_ALPHA_SATURATE",
+        0x0304, "GL_DST_ALPHA",
     },
     {
-     0x2A00,
-     "GL_POLYGON_OFFSET_UNITS",
+        0x0307, "GL_ONE_MINUS_DST_COLOR",
     },
     {
-     0xFFFFFFFF,
-     "GL_ALL_SHADER_BITS_EXT",
+        0x0306, "GL_DST_COLOR",
     },
     {
-     0x82DC,
-     "GL_TEXTURE_VIEW_NUM_LEVELS_EXT",
+        0x0301, "GL_ONE_MINUS_SRC_COLOR",
     },
     {
-     0x8C29,
-     "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT",
+        0x0300, "GL_SRC_COLOR",
     },
     {
-     0x82DD,
-     "GL_TEXTURE_VIEW_MIN_LAYER_EXT",
+        0x0303, "GL_ONE_MINUS_SRC_ALPHA",
     },
     {
-     0x00800000,
-     "GL_STENCIL_BUFFER_BIT7_QCOM",
+        0x0302, "GL_SRC_ALPHA",
     },
     {
-     0x82DE,
-     "GL_TEXTURE_VIEW_NUM_LAYERS_EXT",
+        0x8212, "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE",
     },
     {
-     0x00020000,
-     "GL_STENCIL_BUFFER_BIT1_QCOM",
+        0x8DCC, "GL_INT_SAMPLER_CUBE",
     },
     {
-     0x8D00,
-     "GL_DEPTH_ATTACHMENT",
+        0x0308, "GL_SRC_ALPHA_SATURATE",
     },
     {
-     0x8FA0,
-     "GL_PERFMON_GLOBAL_MODE_QCOM",
+        0x2A00, "GL_POLYGON_OFFSET_UNITS",
     },
     {
-     0x8815,
-     "GL_RGB32F_EXT",
+        0xFFFFFFFF, "GL_ALL_SHADER_BITS_EXT",
     },
     {
-     0x8A35,
-     "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH",
+        0x82DC, "GL_TEXTURE_VIEW_NUM_LEVELS_EXT",
     },
     {
-     0x8814,
-     "GL_RGBA32F_EXT",
+        0x8C29, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT",
     },
     {
-     0x9277,
-     "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2",
+        0x82DD, "GL_TEXTURE_VIEW_MIN_LAYER_EXT",
     },
     {
-     0x6004,
-     "GL_COMMANDS_ISSUED_CHROMIUM",
+        0x00800000, "GL_STENCIL_BUFFER_BIT7_QCOM",
     },
     {
-     0x813D,
-     "GL_TEXTURE_MAX_LEVEL_APPLE",
+        0x82DE, "GL_TEXTURE_VIEW_NUM_LAYERS_EXT",
     },
     {
-     0x8816,
-     "GL_ALPHA32F_EXT",
+        0x00020000, "GL_STENCIL_BUFFER_BIT1_QCOM",
     },
     {
-     0x813B,
-     "GL_TEXTURE_MAX_LOD",
+        0x8D00, "GL_DEPTH_ATTACHMENT",
     },
     {
-     0x8CDD,
-     "GL_FRAMEBUFFER_UNSUPPORTED",
+        0x8FA0, "GL_PERFMON_GLOBAL_MODE_QCOM",
     },
     {
-     0x8CDF,
-     "GL_MAX_COLOR_ATTACHMENTS_EXT",
+        0x8815, "GL_RGB32F_EXT",
     },
     {
-     0x90F3,
-     "GL_CONTEXT_ROBUST_ACCESS_KHR",
+        0x8A35, "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH",
     },
     {
-     0x90F2,
-     "GL_MAX_MULTIVIEW_BUFFERS_EXT",
+        0x8814, "GL_RGBA32F_EXT",
     },
     {
-     0x90F1,
-     "GL_MULTIVIEW_EXT",
+        0x9277, "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2",
     },
     {
-     0x90F0,
-     "GL_COLOR_ATTACHMENT_EXT",
+        0x6004, "GL_COMMANDS_ISSUED_CHROMIUM",
     },
     {
-     0x803C,
-     "GL_ALPHA8_OES",
+        0x813D, "GL_TEXTURE_MAX_LEVEL_APPLE",
     },
     {
-     0x8904,
-     "GL_MIN_PROGRAM_TEXEL_OFFSET",
+        0x8816, "GL_ALPHA32F_EXT",
     },
     {
-     0x84F5,
-     "GL_TEXTURE_RECTANGLE_ARB",
+        0x813B, "GL_TEXTURE_MAX_LOD",
     },
     {
-     0x882A,
-     "GL_DRAW_BUFFER5_EXT",
+        0x8CDD, "GL_FRAMEBUFFER_UNSUPPORTED",
     },
     {
-     0x8E7F,
-     "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT",
+        0x8CDF, "GL_MAX_COLOR_ATTACHMENTS_EXT",
     },
     {
-     0x80AA,
-     "GL_SAMPLE_COVERAGE_VALUE",
+        0x90F3, "GL_CONTEXT_ROBUST_ACCESS_KHR",
     },
     {
-     0x84F6,
-     "GL_TEXTURE_BINDING_RECTANGLE_ARB",
+        0x90F2, "GL_MAX_MULTIVIEW_BUFFERS_EXT",
     },
     {
-     0x80AB,
-     "GL_SAMPLE_COVERAGE_INVERT",
+        0x90F1, "GL_MULTIVIEW_EXT",
     },
     {
-     0x8E7D,
-     "GL_MAX_PATCH_VERTICES_EXT",
+        0x90F0, "GL_COLOR_ATTACHMENT_EXT",
     },
     {
-     0x6005,
-     "GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM",
+        0x803C, "GL_ALPHA8_OES",
     },
     {
-     0x9105,
-     "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES",
+        0x8904, "GL_MIN_PROGRAM_TEXEL_OFFSET",
     },
     {
-     0x8E7E,
-     "GL_MAX_TESS_GEN_LEVEL_EXT",
+        0x84F5, "GL_TEXTURE_RECTANGLE_ARB",
     },
     {
-     0x9102,
-     "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES",
+        0x882A, "GL_DRAW_BUFFER5_EXT",
     },
     {
-     0x8C40,
-     "GL_SRGB_EXT",
+        0x8E7F, "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT",
     },
     {
-     0x8236,
-     "GL_R32UI",
+        0x80AA, "GL_SAMPLE_COVERAGE_VALUE",
     },
     {
-     0x8E7B,
-     "GL_FRACTIONAL_ODD_EXT",
+        0x84F6, "GL_TEXTURE_BINDING_RECTANGLE_ARB",
     },
     {
-     0x00000040,
-     "GL_COLOR_BUFFER_BIT6_QCOM",
+        0x80AB, "GL_SAMPLE_COVERAGE_INVERT",
     },
     {
-     0x882B,
-     "GL_DRAW_BUFFER6_EXT",
+        0x8A3D, "GL_UNIFORM_MATRIX_STRIDE",
     },
     {
-     0x8E7C,
-     "GL_FRACTIONAL_EVEN_EXT",
+        0x8E7D, "GL_MAX_PATCH_VERTICES_EXT",
     },
     {
-     0x8C8E,
-     "GL_TRANSFORM_FEEDBACK_BUFFER",
+        0x9105, "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES",
     },
     {
-     0x8C8D,
-     "GL_SEPARATE_ATTRIBS",
+        0x8E7E, "GL_MAX_TESS_GEN_LEVEL_EXT",
     },
     {
-     0x8C8F,
-     "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING",
+        0x9102, "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES",
     },
     {
-     0x8C8A,
-     "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS",
+        0x8C40, "GL_SRGB_EXT",
     },
     {
-     0x8C8C,
-     "GL_INTERLEAVED_ATTRIBS",
+        0x8236, "GL_R32UI",
     },
     {
-     0x8C8B,
-     "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS",
+        0x8E7B, "GL_FRACTIONAL_ODD_EXT",
     },
     {
-     0x8C17,
-     "GL_UNSIGNED_NORMALIZED_EXT",
+        0x00000040, "GL_COLOR_BUFFER_BIT6_QCOM",
     },
     {
-     0x8A3E,
-     "GL_UNIFORM_IS_ROW_MAJOR",
+        0x882B, "GL_DRAW_BUFFER6_EXT",
     },
     {
-     0x8E7A,
-     "GL_ISOLINES_EXT",
+        0x8E7C, "GL_FRACTIONAL_EVEN_EXT",
     },
     {
-     0x6006,
-     "GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM",
+        0x8C8E, "GL_TRANSFORM_FEEDBACK_BUFFER",
     },
     {
-     0x8D99,
-     "GL_RGBA_INTEGER",
+        0x8C8D, "GL_SEPARATE_ATTRIBS",
     },
     {
-     0x8D98,
-     "GL_RGB_INTEGER",
+        0x8C8F, "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING",
     },
     {
-     0x8A4A,
-     "GL_SKIP_DECODE_EXT",
+        0x8C8A, "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS",
     },
     {
-     0x8A4F,
-     "GL_PROGRAM_PIPELINE_OBJECT_EXT",
+        0x8C8C, "GL_INTERLEAVED_ATTRIBS",
     },
     {
-     0x882C,
-     "GL_DRAW_BUFFER7_EXT",
+        0x8C8B, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS",
     },
     {
-     0x0010,
-     "GL_MAP_FLUSH_EXPLICIT_BIT_EXT",
+        0x8C17, "GL_UNSIGNED_NORMALIZED_EXT",
     },
     {
-     0x8918,
-     "GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT",
+        0x8A3E, "GL_UNIFORM_IS_ROW_MAJOR",
     },
     {
-     0x8919,
-     "GL_SAMPLER_BINDING",
+        0x8E7A, "GL_ISOLINES_EXT",
     },
     {
-     0x92CD,
-     "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT",
+        0x6006, "GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM",
     },
     {
-     0x92CE,
-     "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT",
+        0x8D99, "GL_RGBA_INTEGER",
     },
     {
-     0x8C85,
-     "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE",
+        0x8D98, "GL_RGB_INTEGER",
     },
     {
-     0x8D7C,
-     "GL_RGBA8UI",
+        0x8A4A, "GL_SKIP_DECODE_EXT",
     },
     {
-     0x6007,
-     "GL_LATENCY_QUERY_CHROMIUM",
+        0x8A4F, "GL_PROGRAM_PIPELINE_OBJECT_EXT",
     },
     {
-     0x8D83,
-     "GL_RGB32I",
+        0x882C, "GL_DRAW_BUFFER7_EXT",
     },
     {
-     0x8916,
-     "GL_GEOMETRY_LINKED_VERTICES_OUT_EXT",
+        0x0010, "GL_MAP_FLUSH_EXPLICIT_BIT_EXT",
     },
     {
-     0x8917,
-     "GL_GEOMETRY_LINKED_INPUT_TYPE_EXT",
+        0x8918, "GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT",
     },
     {
-     0x881F,
-     "GL_LUMINANCE_ALPHA16F_EXT",
+        0x8919, "GL_SAMPLER_BINDING",
     },
     {
-     0x84FD,
-     "GL_MAX_TEXTURE_LOD_BIAS",
+        0x92CD, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT",
     },
     {
-     0x882D,
-     "GL_DRAW_BUFFER8_EXT",
+        0x92CE, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT",
     },
     {
-     0x0BA6,
-     "GL_PATH_MODELVIEW_MATRIX_CHROMIUM",
+        0x90A6, "GL_BEVEL_CHROMIUM",
     },
     {
-     0x8A42,
-     "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS",
+        0x90A7, "GL_MITER_REVERT_CHROMIUM",
     },
     {
-     0x8F37,
-     "GL_COPY_WRITE_BUFFER_NV",
+        0x6007, "GL_LATENCY_QUERY_CHROMIUM",
     },
     {
-     0x8F36,
-     "GL_COPY_READ_BUFFER_NV",
+        0x8D83, "GL_RGB32I",
     },
     {
-     0x84FF,
-     "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT",
+        0x8916, "GL_GEOMETRY_LINKED_VERTICES_OUT_EXT",
     },
     {
-     0x8A3C,
-     "GL_UNIFORM_ARRAY_STRIDE",
+        0x8917, "GL_GEOMETRY_LINKED_INPUT_TYPE_EXT",
     },
     {
-     0x8A44,
-     "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER",
+        0x881F, "GL_LUMINANCE_ALPHA16F_EXT",
     },
     {
-     0x6000,
-     "GL_TEXTURE_POOL_CHROMIUM",
+        0x84FD, "GL_MAX_TEXTURE_LOD_BIAS",
     },
     {
-     0x0B74,
-     "GL_DEPTH_FUNC",
+        0x882D, "GL_DRAW_BUFFER8_EXT",
     },
     {
-     0x8A49,
-     "GL_DECODE_EXT",
+        0x0BA6, "GL_PATH_MODELVIEW_MATRIX_CHROMIUM",
     },
     {
-     0x881B,
-     "GL_RGB16F_EXT",
+        0x8A42, "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS",
     },
     {
-     0x0B71,
-     "GL_DEPTH_TEST",
+        0x8F37, "GL_COPY_WRITE_BUFFER_NV",
     },
     {
-     0x0B70,
-     "GL_DEPTH_RANGE",
+        0x8F36, "GL_COPY_READ_BUFFER_NV",
     },
     {
-     0x0B73,
-     "GL_DEPTH_CLEAR_VALUE",
+        0x84FF, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT",
     },
     {
-     0x0B72,
-     "GL_DEPTH_WRITEMASK",
+        0x8A3C, "GL_UNIFORM_ARRAY_STRIDE",
     },
     {
-     0x8BD5,
-     "GL_TEXTURE_INTERNAL_FORMAT_QCOM",
+        0x8A44, "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER",
     },
     {
-     0x85BA,
-     "GL_UNSIGNED_SHORT_8_8_APPLE",
+        0x6000, "GL_TEXTURE_POOL_CHROMIUM",
     },
     {
-     0x8C87,
-     "GL_PRIMITIVES_GENERATED_EXT",
+        0x0B74, "GL_DEPTH_FUNC",
     },
     {
-     0x8C80,
-     "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS",
+        0x8A49, "GL_DECODE_EXT",
     },
     {
-     0x8C83,
-     "GL_TRANSFORM_FEEDBACK_VARYINGS",
+        0x881B, "GL_RGB16F_EXT",
     },
     {
-     0x8D69,
-     "GL_PRIMITIVE_RESTART_FIXED_INDEX",
+        0x0B71, "GL_DEPTH_TEST",
     },
     {
-     0x882E,
-     "GL_DRAW_BUFFER9_EXT",
+        0x0B70, "GL_DEPTH_RANGE",
     },
     {
-     0x8A32,
-     "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT",
+        0x0B73, "GL_DEPTH_CLEAR_VALUE",
     },
     {
-     0x8A31,
-     "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS",
+        0x0B72, "GL_DEPTH_WRITEMASK",
     },
     {
-     0x8C89,
-     "GL_RASTERIZER_DISCARD",
+        0x8BD5, "GL_TEXTURE_INTERNAL_FORMAT_QCOM",
     },
     {
-     0x8C88,
-     "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN",
+        0x85BA, "GL_UNSIGNED_SHORT_8_8_APPLE",
     },
     {
-     0x8C1A,
-     "GL_TEXTURE_2D_ARRAY",
+        0x8C87, "GL_PRIMITIVES_GENERATED_EXT",
     },
     {
-     0x910D,
-     "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES",
+        0x8C80, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS",
     },
     {
-     0x8E80,
-     "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT",
+        0x8C83, "GL_TRANSFORM_FEEDBACK_VARYINGS",
     },
     {
-     0x910B,
-     "GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES",
+        0x8D69, "GL_PRIMITIVE_RESTART_FIXED_INDEX",
     },
     {
-     0x910C,
-     "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES",
+        0x882E, "GL_DRAW_BUFFER9_EXT",
     },
     {
-     0x94FA,
-     "GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL",
+        0x8A32, "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT",
     },
     {
-     0x8073,
-     "GL_MAX_3D_TEXTURE_SIZE_OES",
+        0x8A31, "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS",
     },
     {
-     0x8072,
-     "GL_TEXTURE_WRAP_R_OES",
+        0x8C89, "GL_RASTERIZER_DISCARD",
     },
     {
-     0x9289,
-     "GL_DST_OVER_NV",
+        0x8C88, "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN",
     },
     {
-     0x882F,
-     "GL_DRAW_BUFFER10_EXT",
+        0x8C1A, "GL_TEXTURE_2D_ARRAY",
     },
     {
-     0x8074,
-     "GL_VERTEX_ARRAY_KHR",
+        0x910D, "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES",
     },
     {
-     0x80E1,
-     "GL_BGRA_EXT",
+        0x8E80, "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT",
     },
     {
-     0x8ED7,
-     "GL_COVERAGE_AUTOMATIC_NV",
+        0x910B, "GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES",
     },
     {
-     0x8ED6,
-     "GL_COVERAGE_EDGE_FRAGMENTS_NV",
+        0x910C, "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES",
     },
     {
-     0x8ED5,
-     "GL_COVERAGE_ALL_FRAGMENTS_NV",
+        0x94FA, "GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL",
     },
     {
-     0x8ED4,
-     "GL_COVERAGE_SAMPLES_NV",
+        0x8073, "GL_MAX_3D_TEXTURE_SIZE_OES",
     },
     {
-     0x8ED3,
-     "GL_COVERAGE_BUFFERS_NV",
+        0x8072, "GL_TEXTURE_WRAP_R_OES",
     },
     {
-     0x8ED2,
-     "GL_COVERAGE_ATTACHMENT_NV",
+        0x9289, "GL_DST_OVER_NV",
     },
     {
-     0x8ED1,
-     "GL_COVERAGE_COMPONENT4_NV",
+        0x882F, "GL_DRAW_BUFFER10_EXT",
     },
     {
-     0x8ED0,
-     "GL_COVERAGE_COMPONENT_NV",
+        0x8074, "GL_VERTEX_ARRAY_KHR",
     },
     {
-     0x8217,
-     "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE",
+        0x80E1, "GL_BGRA_EXT",
     },
     {
-     0x8E89,
-     "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT",
+        0x8ED7, "GL_COVERAGE_AUTOMATIC_NV",
     },
     {
-     0x8216,
-     "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE",
+        0x8ED6, "GL_COVERAGE_EDGE_FRAGMENTS_NV",
     },
     {
-     0x8A36,
-     "GL_ACTIVE_UNIFORM_BLOCKS",
+        0x8ED5, "GL_COVERAGE_ALL_FRAGMENTS_NV",
     },
     {
-     0x8A37,
-     "GL_UNIFORM_TYPE",
+        0x8ED4, "GL_COVERAGE_SAMPLES_NV",
     },
     {
-     0x8A34,
-     "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT",
+        0x8ED3, "GL_COVERAGE_BUFFERS_NV",
     },
     {
-     0x3006,
-     "GL_CLIP_DISTANCE6_APPLE",
+        0x8ED2, "GL_COVERAGE_ATTACHMENT_NV",
     },
     {
-     0x800B,
-     "GL_FUNC_REVERSE_SUBTRACT",
+        0x8ED1, "GL_COVERAGE_COMPONENT4_NV",
     },
     {
-     0x8A33,
-     "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS",
+        0x8ED0, "GL_COVERAGE_COMPONENT_NV",
     },
     {
-     0x00000400,
-     "GL_STENCIL_BUFFER_BIT",
+        0x8217, "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE",
     },
     {
-     0x800A,
-     "GL_FUNC_SUBTRACT",
+        0x8E89, "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT",
     },
     {
-     0x8214,
-     "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE",
+        0x8216, "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE",
     },
     {
-     0x8A38,
-     "GL_UNIFORM_SIZE",
+        0x8A36, "GL_ACTIVE_UNIFORM_BLOCKS",
     },
     {
-     0x8A39,
-     "GL_UNIFORM_NAME_LENGTH",
+        0x8A37, "GL_UNIFORM_TYPE",
     },
     {
-     0x8E2C,
-     "GL_DEPTH_COMPONENT16_NONLINEAR_NV",
+        0x8A34, "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT",
     },
     {
-     0x889F,
-     "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",
+        0x3006, "GL_CLIP_DISTANCE6_APPLE",
     },
     {
-     0x8219,
-     "GL_FRAMEBUFFER_UNDEFINED_OES",
+        0x800B, "GL_FUNC_REVERSE_SUBTRACT",
     },
     {
-     0x8E23,
-     "GL_TRANSFORM_FEEDBACK_PAUSED",
+        0x8A33, "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS",
     },
     {
-     0x8E22,
-     "GL_TRANSFORM_FEEDBACK",
+        0x00000400, "GL_STENCIL_BUFFER_BIT",
     },
     {
-     0x8E25,
-     "GL_TRANSFORM_FEEDBACK_BINDING",
+        0x800A, "GL_FUNC_SUBTRACT",
     },
     {
-     0x9054,
-     "GL_IMAGE_CUBE_MAP_ARRAY_EXT",
+        0x8214, "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE",
     },
     {
-     0x8E28,
-     "GL_TIMESTAMP_EXT",
+        0x8A38, "GL_UNIFORM_SIZE",
     },
     {
-     0x8006,
-     "GL_FUNC_ADD",
+        0x8A39, "GL_UNIFORM_NAME_LENGTH",
     },
     {
-     0x8007,
-     "GL_MIN_EXT",
+        0x8E2C, "GL_DEPTH_COMPONENT16_NONLINEAR_NV",
     },
     {
-     0x8004,
-     "GL_ONE_MINUS_CONSTANT_ALPHA",
+        0x889F, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",
     },
     {
-     0x8005,
-     "GL_BLEND_COLOR",
+        0x8219, "GL_FRAMEBUFFER_UNDEFINED_OES",
     },
     {
-     0x8002,
-     "GL_ONE_MINUS_CONSTANT_COLOR",
+        0x8E23, "GL_TRANSFORM_FEEDBACK_PAUSED",
     },
     {
-     0x8003,
-     "GL_CONSTANT_ALPHA",
+        0x8E22, "GL_TRANSFORM_FEEDBACK",
     },
     {
-     0x8001,
-     "GL_CONSTANT_COLOR",
+        0x8E25, "GL_TRANSFORM_FEEDBACK_BINDING",
     },
     {
-     0x0204,
-     "GL_GREATER",
+        0x9054, "GL_IMAGE_CUBE_MAP_ARRAY_EXT",
     },
     {
-     0x0205,
-     "GL_NOTEQUAL",
+        0x8E28, "GL_TIMESTAMP_EXT",
     },
     {
-     0x0206,
-     "GL_GEQUAL",
+        0x8006, "GL_FUNC_ADD",
     },
     {
-     0x0207,
-     "GL_ALWAYS",
+        0x8007, "GL_MIN_EXT",
     },
     {
-     0x0200,
-     "GL_NEVER",
+        0x8004, "GL_ONE_MINUS_CONSTANT_ALPHA",
     },
     {
-     0x0201,
-     "GL_LESS",
+        0x8005, "GL_BLEND_COLOR",
     },
     {
-     0x0202,
-     "GL_EQUAL",
+        0x8002, "GL_ONE_MINUS_CONSTANT_COLOR",
     },
     {
-     0x0203,
-     "GL_LEQUAL",
+        0x8003, "GL_CONSTANT_ALPHA",
     },
     {
-     0x8BD6,
-     "GL_TEXTURE_FORMAT_QCOM",
+        0x8001, "GL_CONSTANT_COLOR",
     },
     {
-     0x8228,
-     "GL_RG_INTEGER",
+        0x0204, "GL_GREATER",
     },
     {
-     0x2901,
-     "GL_REPEAT",
+        0x0205, "GL_NOTEQUAL",
     },
     {
-     0x9067,
-     "GL_UNSIGNED_INT_IMAGE_BUFFER_EXT",
+        0x0206, "GL_GEQUAL",
     },
     {
-     0x92A0,
-     "GL_EXCLUSION_KHR",
+        0x0207, "GL_ALWAYS",
     },
     {
-     0x93D8,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR",
+        0x0200, "GL_NEVER",
     },
     {
-     0x93D9,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR",
+        0x0201, "GL_LESS",
     },
     {
-     0x8FB2,
-     "GL_GPU_OPTIMIZED_QCOM",
+        0x0202, "GL_EQUAL",
     },
     {
-     0x190A,
-     "GL_LUMINANCE_ALPHA",
+        0x0203, "GL_LEQUAL",
     },
     {
-     0x8FB0,
-     "GL_BINNING_CONTROL_HINT_QCOM",
+        0x8DC6, "GL_UNSIGNED_INT_VEC2",
     },
     {
-     0x905C,
-     "GL_INT_IMAGE_BUFFER_EXT",
+        0x8BD6, "GL_TEXTURE_FORMAT_QCOM",
     },
     {
-     0x1E00,
-     "GL_KEEP",
+        0x8228, "GL_RG_INTEGER",
     },
     {
-     0x1E01,
-     "GL_REPLACE",
+        0x2901, "GL_REPEAT",
     },
     {
-     0x1E02,
-     "GL_INCR",
+        0x9067, "GL_UNSIGNED_INT_IMAGE_BUFFER_EXT",
     },
     {
-     0x1E03,
-     "GL_DECR",
+        0x92A0, "GL_EXCLUSION_KHR",
     },
     {
-     0x93D6,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR",
+        0x93D8, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR",
     },
     {
-     0x93D7,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR",
+        0x93D9, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR",
     },
     {
-     0x93D4,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR",
+        0x8FB2, "GL_GPU_OPTIMIZED_QCOM",
     },
     {
-     0x93D5,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR",
+        0x190A, "GL_LUMINANCE_ALPHA",
     },
     {
-     0x886D,
-     "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT",
+        0x8FB0, "GL_BINNING_CONTROL_HINT_QCOM",
     },
     {
-     0x0BE2,
-     "GL_BLEND",
+        0x905C, "GL_INT_IMAGE_BUFFER_EXT",
     },
     {
-     0x84CB,
-     "GL_TEXTURE11",
+        0x1E00, "GL_KEEP",
     },
     {
-     0x8D55,
-     "GL_RENDERBUFFER_STENCIL_SIZE",
+        0x1E01, "GL_REPLACE",
     },
     {
-     0x8D54,
-     "GL_RENDERBUFFER_DEPTH_SIZE",
+        0x1E02, "GL_INCR",
     },
     {
-     0x8D57,
-     "GL_MAX_SAMPLES_ANGLE",
+        0x1E03, "GL_DECR",
     },
     {
-     0x8D56,
-     "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE",
+        0x93D6, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR",
     },
     {
-     0x8D51,
-     "GL_RENDERBUFFER_GREEN_SIZE",
+        0x93D7, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR",
     },
     {
-     0x8D50,
-     "GL_RENDERBUFFER_RED_SIZE",
+        0x93D4, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR",
     },
     {
-     0x8D53,
-     "GL_RENDERBUFFER_ALPHA_SIZE",
+        0x93D5, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR",
     },
     {
-     0x8D52,
-     "GL_RENDERBUFFER_BLUE_SIZE",
+        0x886D, "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT",
     },
     {
-     0x92A6,
-     "GL_VIVIDLIGHT_NV",
+        0x0BE2, "GL_BLEND",
     },
     {
-     0x8A2A,
-     "GL_UNIFORM_BUFFER_SIZE",
+        0x84CB, "GL_TEXTURE11",
     },
     {
-     0x8DCC,
-     "GL_INT_SAMPLER_CUBE",
+        0x8D55, "GL_RENDERBUFFER_STENCIL_SIZE",
     },
     {
-     0x78F1,
-     "GL_MAP_CHROMIUM",
+        0x8D54, "GL_RENDERBUFFER_DEPTH_SIZE",
     },
     {
-     0x00080000,
-     "GL_STENCIL_BUFFER_BIT3_QCOM",
+        0x8D57, "GL_MAX_SAMPLES_ANGLE",
     },
     {
-     0x92A7,
-     "GL_LINEARLIGHT_NV",
+        0x8D56, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE",
     },
     {
-     0x8DCF,
-     "GL_INT_SAMPLER_2D_ARRAY",
+        0x8D51, "GL_RENDERBUFFER_GREEN_SIZE",
     },
     {
-     0x886A,
-     "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED",
+        0x8D50, "GL_RENDERBUFFER_RED_SIZE",
     },
     {
-     0x8C41,
-     "GL_SRGB8_NV",
+        0x8D53, "GL_RENDERBUFFER_ALPHA_SIZE",
     },
     {
-     0x0C01,
-     "GL_DRAW_BUFFER_EXT",
+        0x8D52, "GL_RENDERBUFFER_BLUE_SIZE",
     },
     {
-     0x886C,
-     "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT",
+        0x92A6, "GL_VIVIDLIGHT_NV",
     },
     {
-     0x90CB,
-     "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT",
+        0x8A2A, "GL_UNIFORM_BUFFER_SIZE",
     },
     {
-     0x8DCA,
-     "GL_INT_SAMPLER_2D",
+        0x04, "GL_LINE_TO_CHROMIUM",
     },
     {
-     0x93C7,
-     "GL_COMPRESSED_RGBA_ASTC_6x5x5_OES",
+        0x0BA7, "GL_PATH_PROJECTION_MATRIX_CHROMIUM",
     },
     {
-     0x8B5F,
-     "GL_SAMPLER_3D_OES",
+        0x00080000, "GL_STENCIL_BUFFER_BIT3_QCOM",
     },
     {
-     0x8B95,
-     "GL_PALETTE8_RGB8_OES",
+        0x92A7, "GL_LINEARLIGHT_NV",
     },
     {
-     0x9250,
-     "GL_SHADER_BINARY_DMP",
+        0x00, "GL_CLOSE_PATH_CHROMIUM",
     },
     {
-     0x9251,
-     "GL_SMAPHS30_PROGRAM_BINARY_DMP",
+        0x8DCF, "GL_INT_SAMPLER_2D_ARRAY",
     },
     {
-     0x9252,
-     "GL_SMAPHS_PROGRAM_BINARY_DMP",
+        0x02, "GL_MOVE_TO_CHROMIUM",
     },
     {
-     0x9253,
-     "GL_DMP_PROGRAM_BINARY_DMP",
+        0x886A, "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED",
     },
     {
-     0x8DC8,
-     "GL_UNSIGNED_INT_VEC4",
+        0x8C41, "GL_SRGB8_NV",
     },
     {
-     0x3000,
-     "GL_CLIP_DISTANCE0_APPLE",
+        0x9079, "GL_PATH_JOIN_STYLE_CHROMIUM",
     },
     {
-     0x8C92,
-     "GL_ATC_RGB_AMD",
+        0x0C01, "GL_DRAW_BUFFER_EXT",
     },
     {
-     0x8DC1,
-     "GL_SAMPLER_2D_ARRAY",
+        0x9075, "GL_PATH_STROKE_WIDTH_CHROMIUM",
     },
     {
-     0x9154,
-     "GL_VERTEX_ARRAY_OBJECT_EXT",
+        0x9076, "GL_PATH_END_CAPS_CHROMIUM",
     },
     {
-     0x9153,
-     "GL_QUERY_OBJECT_EXT",
+        0x886C, "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT",
     },
     {
-     0x8864,
-     "GL_QUERY_COUNTER_BITS_EXT",
+        0x90CB, "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT",
     },
     {
-     0x9151,
-     "GL_BUFFER_OBJECT_EXT",
+        0x9086, "GL_PATH_STROKE_BOUND_CHROMIUM",
     },
     {
-     0x8C93,
-     "GL_ATC_RGBA_EXPLICIT_ALPHA_AMD",
+        0x93C7, "GL_COMPRESSED_RGBA_ASTC_6x5x5_OES",
     },
     {
-     0x00000002,
-     "GL_CONTEXT_FLAG_DEBUG_BIT_KHR",
+        0x8B5F, "GL_SAMPLER_3D_OES",
     },
     {
-     0x8A3F,
-     "GL_UNIFORM_BLOCK_BINDING",
+        0x8B95, "GL_PALETTE8_RGB8_OES",
     },
     {
-     0x00000000,
-     "GL_PERFQUERY_SINGLE_CONTEXT_INTEL",
+        0x9250, "GL_SHADER_BINARY_DMP",
     },
     {
-     0x00000001,
-     "GL_SYNC_FLUSH_COMMANDS_BIT_APPLE",
+        0x9251, "GL_SMAPHS30_PROGRAM_BINARY_DMP",
     },
     {
-     0x9248,
-     "GL_OVERLAY_TRANSFORM_ROTATE_90_CHROMIUM",
+        0x9252, "GL_SMAPHS_PROGRAM_BINARY_DMP",
     },
     {
-     0x00000004,
-     "GL_GEOMETRY_SHADER_BIT_EXT",
+        0x9253, "GL_DMP_PROGRAM_BINARY_DMP",
     },
     {
-     0x1702,
-     "GL_TEXTURE",
+        0x8DC8, "GL_UNSIGNED_INT_VEC4",
     },
     {
-     0x3003,
-     "GL_CLIP_DISTANCE3_APPLE",
+        0x3000, "GL_CLIP_DISTANCE0_APPLE",
     },
     {
-     0x00000008,
-     "GL_TESS_CONTROL_SHADER_BIT_EXT",
+        0x8C92, "GL_ATC_RGB_AMD",
     },
     {
-     0x8B58,
-     "GL_BOOL_VEC3",
+        0x8DC1, "GL_SAMPLER_2D_ARRAY",
     },
     {
-     0x8A3D,
-     "GL_UNIFORM_MATRIX_STRIDE",
+        0x9154, "GL_VERTEX_ARRAY_OBJECT_EXT",
     },
     {
-     0x8828,
-     "GL_DRAW_BUFFER3_EXT",
+        0x9153, "GL_QUERY_OBJECT_EXT",
     },
     {
-     0x8DF0,
-     "GL_LOW_FLOAT",
+        0x8864, "GL_QUERY_COUNTER_BITS_EXT",
     },
     {
-     0x1906,
-     "GL_ALPHA",
+        0x9151, "GL_BUFFER_OBJECT_EXT",
     },
     {
-     0x1907,
-     "GL_RGB",
+        0x8C93, "GL_ATC_RGBA_EXPLICIT_ALPHA_AMD",
     },
     {
-     0x8FBB,
-     "GL_GPU_DISJOINT_EXT",
+        0x00000002, "GL_CONTEXT_FLAG_DEBUG_BIT_KHR",
     },
     {
-     0x1901,
-     "GL_STENCIL_INDEX_OES",
+        0x8A3F, "GL_UNIFORM_BLOCK_BINDING",
     },
     {
-     0x1902,
-     "GL_DEPTH_COMPONENT",
+        0x00000000, "GL_PERFQUERY_SINGLE_CONTEXT_INTEL",
     },
     {
-     0x8B56,
-     "GL_BOOL",
+        0x00000001, "GL_SYNC_FLUSH_COMMANDS_BIT_APPLE",
     },
     {
-     0x93DB,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR",
+        0x9248, "GL_OVERLAY_TRANSFORM_ROTATE_90_CHROMIUM",
     },
     {
-     0x8B9B,
-     "GL_IMPLEMENTATION_COLOR_READ_FORMAT",
+        0x00000004, "GL_GEOMETRY_SHADER_BIT_EXT",
     },
     {
-     0x8B9A,
-     "GL_IMPLEMENTATION_COLOR_READ_TYPE",
+        0x1702, "GL_TEXTURE",
     },
     {
-     0x93DA,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR",
+        0x3003, "GL_CLIP_DISTANCE3_APPLE",
     },
     {
-     0x1908,
-     "GL_RGBA",
+        0x00000008, "GL_TESS_CONTROL_SHADER_BIT_EXT",
     },
     {
-     0x8DF2,
-     "GL_HIGH_FLOAT",
+        0x8B58, "GL_BOOL_VEC3",
     },
     {
-     0x93DD,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR",
+        0x907a, "GL_PATH_MITER_LIMIT_CHROMIUM",
     },
     {
-     0x8827,
-     "GL_DRAW_BUFFER2_EXT",
+        0x8828, "GL_DRAW_BUFFER3_EXT",
     },
     {
-     0x9243,
-     "GL_UNPACK_COLORSPACE_CONVERSION_CHROMIUM",
+        0x8DF0, "GL_LOW_FLOAT",
     },
     {
-     0x8DF3,
-     "GL_LOW_INT",
+        0x1906, "GL_ALPHA",
     },
     {
-     0x82E8,
-     "GL_MAX_LABEL_LENGTH_KHR",
+        0x1907, "GL_RGB",
     },
     {
-     0x82E6,
-     "GL_SAMPLER_KHR",
+        0x8FBB, "GL_GPU_DISJOINT_EXT",
     },
     {
-     0x0C02,
-     "GL_READ_BUFFER_EXT",
+        0x1901, "GL_STENCIL_INDEX_OES",
     },
     {
-     0x82E3,
-     "GL_QUERY_KHR",
+        0x1902, "GL_DEPTH_COMPONENT",
     },
     {
-     0x82E2,
-     "GL_PROGRAM_KHR",
+        0x8B56, "GL_BOOL",
     },
     {
-     0x82E1,
-     "GL_SHADER_KHR",
+        0x93DB, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR",
     },
     {
-     0x8B52,
-     "GL_FLOAT_VEC4",
+        0x8B9B, "GL_IMPLEMENTATION_COLOR_READ_FORMAT",
     },
     {
-     0x8239,
-     "GL_RG16I",
+        0x8B9A, "GL_IMPLEMENTATION_COLOR_READ_TYPE",
     },
     {
-     0x8238,
-     "GL_RG8UI",
+        0x93DA, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR",
     },
     {
-     0x9240,
-     "GL_UNPACK_FLIP_Y_CHROMIUM",
+        0x1908, "GL_RGBA",
     },
     {
-     0x8DF6,
-     "GL_UNSIGNED_INT_10_10_10_2_OES",
+        0x8DF2, "GL_HIGH_FLOAT",
     },
     {
-     0x8A30,
-     "GL_MAX_UNIFORM_BLOCK_SIZE",
+        0x93DD, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR",
     },
     {
-     0x9273,
-     "GL_COMPRESSED_SIGNED_RG11_EAC",
+        0x8827, "GL_DRAW_BUFFER2_EXT",
     },
     {
-     0x8231,
-     "GL_R8I",
+        0x9243, "GL_UNPACK_COLORSPACE_CONVERSION_CHROMIUM",
     },
     {
-     0x8866,
-     "GL_QUERY_RESULT_EXT",
+        0x8DF3, "GL_LOW_INT",
     },
     {
-     0x8233,
-     "GL_R16I",
+        0x82E8, "GL_MAX_LABEL_LENGTH_KHR",
     },
     {
-     0x8DF7,
-     "GL_INT_10_10_10_2_OES",
+        0x82E6, "GL_SAMPLER_KHR",
     },
     {
-     0x8235,
-     "GL_R32I",
+        0x0C02, "GL_READ_BUFFER_EXT",
     },
     {
-     0x8234,
-     "GL_R16UI",
+        0x82E3, "GL_QUERY_KHR",
     },
     {
-     0x8237,
-     "GL_RG8I",
+        0x82E2, "GL_PROGRAM_KHR",
     },
     {
-     0x9246,
-     "GL_OVERLAY_TRANSFORM_FLIP_HORIZONTAL_CHROMIUM",
+        0x82E1, "GL_SHADER_KHR",
     },
     {
-     0x8B69,
-     "GL_FLOAT_MAT4x2_NV",
+        0x8B52, "GL_FLOAT_VEC4",
     },
     {
-     0x812D,
-     "GL_CLAMP_TO_BORDER_EXT",
+        0x8239, "GL_RG16I",
     },
     {
-     0x812F,
-     "GL_CLAMP_TO_EDGE",
+        0x8238, "GL_RG8UI",
     },
     {
-     0x92A4,
-     "GL_LINEARDODGE_NV",
+        0x8DF6, "GL_UNSIGNED_INT_10_10_10_2_OES",
     },
     {
-     0x8DD8,
-     "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT",
+        0x8A30, "GL_MAX_UNIFORM_BLOCK_SIZE",
     },
     {
-     0x8DD9,
-     "GL_GEOMETRY_SHADER_EXT",
+        0x9273, "GL_COMPRESSED_SIGNED_RG11_EAC",
     },
     {
-     0x86A3,
-     "GL_COMPRESSED_TEXTURE_FORMATS",
+        0x8231, "GL_R8I",
     },
     {
-     0x8DD4,
-     "GL_UNSIGNED_INT_SAMPLER_CUBE",
+        0x8866, "GL_QUERY_RESULT_EXT",
     },
     {
-     0x9244,
-     "GL_BIND_GENERATES_RESOURCE_CHROMIUM",
+        0x8233, "GL_R16I",
     },
     {
-     0x8DD2,
-     "GL_UNSIGNED_INT_SAMPLER_2D",
+        0x8DF7, "GL_INT_10_10_10_2_OES",
     },
     {
-     0x8DD3,
-     "GL_UNSIGNED_INT_SAMPLER_3D",
+        0x8235, "GL_R32I",
     },
     {
-     0x8DD0,
-     "GL_INT_SAMPLER_BUFFER_EXT",
+        0x8234, "GL_R16UI",
     },
     {
-     0x86A2,
-     "GL_NUM_COMPRESSED_TEXTURE_FORMATS",
+        0x8237, "GL_RG8I",
     },
     {
-     0x0CF3,
-     "GL_UNPACK_SKIP_ROWS_EXT",
+        0x9246, "GL_OVERLAY_TRANSFORM_FLIP_HORIZONTAL_CHROMIUM",
     },
     {
-     0x0CF2,
-     "GL_UNPACK_ROW_LENGTH_EXT",
+        0x8B69, "GL_FLOAT_MAT4x2_NV",
     },
     {
-     0x140C,
-     "GL_FIXED",
+        0x812D, "GL_CLAMP_TO_BORDER_EXT",
     },
     {
-     0x140B,
-     "GL_HALF_FLOAT",
+        0x812F, "GL_CLAMP_TO_EDGE",
     },
     {
-     0x8008,
-     "GL_MAX_EXT",
+        0x92A4, "GL_LINEARDODGE_NV",
     },
     {
-     0x0CF5,
-     "GL_UNPACK_ALIGNMENT",
+        0x8DD8, "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT",
     },
     {
-     0x8867,
-     "GL_QUERY_RESULT_AVAILABLE_EXT",
+        0x8DD9, "GL_GEOMETRY_SHADER_EXT",
     },
     {
-     0x8D82,
-     "GL_RGBA32I",
+        0x86A3, "GL_COMPRESSED_TEXTURE_FORMATS",
     },
     {
-     0x8009,
-     "GL_BLEND_EQUATION",
+        0x8DD4, "GL_UNSIGNED_INT_SAMPLER_CUBE",
     },
     {
-     0x911F,
-     "GL_BUFFER_ACCESS_FLAGS",
+        0x9244, "GL_BIND_GENERATES_RESOURCE_CHROMIUM",
     },
     {
-     0x1401,
-     "GL_UNSIGNED_BYTE",
+        0x8DD2, "GL_UNSIGNED_INT_SAMPLER_2D",
     },
     {
-     0x1400,
-     "GL_BYTE",
+        0x8DD3, "GL_UNSIGNED_INT_SAMPLER_3D",
     },
     {
-     0x1403,
-     "GL_UNSIGNED_SHORT",
+        0x8DD0, "GL_INT_SAMPLER_BUFFER_EXT",
     },
     {
-     0x1402,
-     "GL_SHORT",
+        0x86A2, "GL_NUM_COMPRESSED_TEXTURE_FORMATS",
     },
     {
-     0x1405,
-     "GL_UNSIGNED_INT",
+        0x0CF3, "GL_UNPACK_SKIP_ROWS_EXT",
     },
     {
-     0x1404,
-     "GL_INT",
+        0x0CF2, "GL_UNPACK_ROW_LENGTH_EXT",
     },
     {
-     0x1406,
-     "GL_FLOAT",
+        0x140C, "GL_FIXED",
     },
     {
-     0x8C1D,
-     "GL_TEXTURE_BINDING_2D_ARRAY",
+        0x140B, "GL_HALF_FLOAT",
     },
     {
-     0x8DDF,
-     "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT",
+        0x8008, "GL_MAX_EXT",
     },
     {
-     0x8043,
-     "GL_LUMINANCE4_ALPHA4_OES",
+        0x0CF5, "GL_UNPACK_ALIGNMENT",
     },
     {
-     0x8040,
-     "GL_LUMINANCE8_OES",
+        0x8867, "GL_QUERY_RESULT_AVAILABLE_EXT",
     },
     {
-     0x8045,
-     "GL_LUMINANCE8_ALPHA8_OES",
+        0x8D82, "GL_RGBA32I",
     },
     {
-     0x8CD1,
-     "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",
+        0x8009, "GL_BLEND_EQUATION",
     },
     {
-     0x00040000,
-     "GL_STENCIL_BUFFER_BIT2_QCOM",
+        0x911F, "GL_BUFFER_ACCESS_FLAGS",
     },
     {
-     0x8CD0,
-     "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",
+        0x1401, "GL_UNSIGNED_BYTE",
     },
     {
-     0x823A,
-     "GL_RG16UI",
+        0x1400, "GL_BYTE",
     },
     {
-     0x8CE4,
-     "GL_COLOR_ATTACHMENT4_EXT",
+        0x1403, "GL_UNSIGNED_SHORT",
     },
     {
-     0x823B,
-     "GL_RG32I",
+        0x1402, "GL_SHORT",
     },
     {
-     0x8CD3,
-     "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",
+        0x1405, "GL_UNSIGNED_INT",
     },
     {
-     0x846E,
-     "GL_ALIASED_LINE_WIDTH_RANGE",
+        0x1404, "GL_INT",
     },
     {
-     0x0B90,
-     "GL_STENCIL_TEST",
+        0x1406, "GL_FLOAT",
     },
     {
-     0x8CD2,
-     "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",
+        0x8C1D, "GL_TEXTURE_BINDING_2D_ARRAY",
     },
     {
-     0x881C,
-     "GL_ALPHA16F_EXT",
+        0x8DDF, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT",
     },
     {
-     0x928E,
-     "GL_SRC_ATOP_NV",
+        0x8043, "GL_LUMINANCE4_ALPHA4_OES",
     },
     {
-     0x8CD4,
-     "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES",
+        0x8040, "GL_LUMINANCE8_OES",
     },
     {
-     0x9113,
-     "GL_SYNC_CONDITION_APPLE",
+        0x8045, "GL_LUMINANCE8_ALPHA8_OES",
     },
     {
-     0x8CD7,
-     "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",
+        0x8CD1, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",
     },
     {
-     0x08000000,
-     "GL_MULTISAMPLE_BUFFER_BIT3_QCOM",
+        0x00040000, "GL_STENCIL_BUFFER_BIT2_QCOM",
     },
     {
-     0x93A4,
-     "GL_PACK_REVERSE_ROW_ORDER_ANGLE",
+        0x8CD0, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",
     },
     {
-     0x8038,
-     "GL_POLYGON_OFFSET_FACTOR",
+        0x823A, "GL_RG16UI",
     },
     {
-     0x94F9,
-     "GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL",
+        0x8CE4, "GL_COLOR_ATTACHMENT4_EXT",
     },
     {
-     0x851A,
-     "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z",
+        0x823B, "GL_RG32I",
     },
     {
-     0x851C,
-     "GL_MAX_CUBE_MAP_TEXTURE_SIZE",
+        0x8CD3, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",
     },
     {
-     0x8CD9,
-     "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
+        0x846E, "GL_ALIASED_LINE_WIDTH_RANGE",
     },
     {
-     0x84CC,
-     "GL_TEXTURE12",
+        0x0B90, "GL_STENCIL_TEST",
     },
     {
-     0x0BA2,
-     "GL_VIEWPORT",
+        0x8CD2, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",
     },
     {
-     0x84CA,
-     "GL_TEXTURE10",
+        0x881C, "GL_ALPHA16F_EXT",
     },
     {
-     0x0BA7,
-     "GL_PATH_PROJECTION_MATRIX_CHROMIUM",
+        0x928E, "GL_SRC_ATOP_NV",
     },
     {
-     0x84CF,
-     "GL_TEXTURE15",
+        0x8CD4, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES",
     },
     {
-     0x84CE,
-     "GL_TEXTURE14",
+        0x9113, "GL_SYNC_CONDITION_APPLE",
     },
     {
-     0x84CD,
-     "GL_TEXTURE13",
+        0x8CD7, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",
     },
     {
-     0x83F9,
-     "GL_PERFQUERY_DONOT_FLUSH_INTEL",
+        0x08000000, "GL_MULTISAMPLE_BUFFER_BIT3_QCOM",
     },
     {
-     0x9115,
-     "GL_SYNC_FLAGS_APPLE",
+        0x93A4, "GL_PACK_REVERSE_ROW_ORDER_ANGLE",
     },
     {
-     0x9286,
-     "GL_SRC_NV",
+        0x8038, "GL_POLYGON_OFFSET_FACTOR",
     },
     {
-     0x83F3,
-     "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE",
+        0x94F9, "GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL",
     },
     {
-     0x83F2,
-     "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE",
+        0x851A, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z",
     },
     {
-     0x83F1,
-     "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT",
+        0x851C, "GL_MAX_CUBE_MAP_TEXTURE_SIZE",
     },
     {
-     0x9114,
-     "GL_SYNC_STATUS_APPLE",
+        0x8CD9, "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
     },
     {
-     0x8C0A,
-     "GL_SGX_BINARY_IMG",
+        0x84CC, "GL_TEXTURE12",
     },
     {
-     0x93BB,
-     "GL_COMPRESSED_RGBA_ASTC_10x10_KHR",
+        0x0BA2, "GL_VIEWPORT",
     },
     {
-     0x911C,
-     "GL_CONDITION_SATISFIED_APPLE",
+        0x84CA, "GL_TEXTURE10",
     },
     {
-     0x911B,
-     "GL_TIMEOUT_EXPIRED_APPLE",
+        0x78F1, "GL_MAP_CHROMIUM",
     },
     {
-     0x911A,
-     "GL_ALREADY_SIGNALED_APPLE",
+        0x84CF, "GL_TEXTURE15",
     },
     {
-     0x9284,
-     "GL_CONJOINT_NV",
+        0x84CE, "GL_TEXTURE14",
     },
     {
-     0x9124,
-     "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT",
+        0x84CD, "GL_TEXTURE13",
     },
     {
-     0x911D,
-     "GL_WAIT_FAILED_APPLE",
+        0x83F9, "GL_PERFQUERY_DONOT_FLUSH_INTEL",
     },
     {
-     0x929A,
-     "GL_COLORBURN_KHR",
+        0x9115, "GL_SYNC_FLAGS_APPLE",
     },
     {
-     0x929B,
-     "GL_HARDLIGHT_KHR",
+        0x9286, "GL_SRC_NV",
     },
     {
-     0x929C,
-     "GL_SOFTLIGHT_KHR",
+        0x83F3, "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE",
     },
     {
-     0x846D,
-     "GL_ALIASED_POINT_SIZE_RANGE",
+        0x83F2, "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE",
     },
     {
-     0x929E,
-     "GL_DIFFERENCE_KHR",
+        0x83F1, "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT",
     },
     {
-     0x929F,
-     "GL_MINUS_NV",
+        0x9114, "GL_SYNC_STATUS_APPLE",
     },
     {
-     0x9282,
-     "GL_UNCORRELATED_NV",
+        0x8C0A, "GL_SGX_BINARY_IMG",
     },
     {
-     0x9298,
-     "GL_LIGHTEN_KHR",
+        0x93BB, "GL_COMPRESSED_RGBA_ASTC_10x10_KHR",
     },
     {
-     0x9299,
-     "GL_COLORDODGE_KHR",
+        0x911C, "GL_CONDITION_SATISFIED_APPLE",
     },
     {
-     0x9111,
-     "GL_MAX_SERVER_WAIT_TIMEOUT_APPLE",
+        0x911B, "GL_TIMEOUT_EXPIRED_APPLE",
     },
     {
-     0x93A6,
-     "GL_PROGRAM_BINARY_ANGLE",
+        0x911A, "GL_ALREADY_SIGNALED_APPLE",
     },
     {
-     0x9117,
-     "GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE",
+        0x9284, "GL_CONJOINT_NV",
     },
     {
-     0x93A0,
-     "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE",
+        0x9124, "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT",
     },
     {
-     0x93A3,
-     "GL_FRAMEBUFFER_ATTACHMENT_ANGLE",
+        0x911D, "GL_WAIT_FAILED_APPLE",
     },
     {
-     0x93A2,
-     "GL_TEXTURE_USAGE_ANGLE",
+        0x929A, "GL_COLORBURN_KHR",
     },
     {
-     0x8802,
-     "GL_STENCIL_BACK_PASS_DEPTH_FAIL",
+        0x929B, "GL_HARDLIGHT_KHR",
     },
     {
-     0x9119,
-     "GL_SIGNALED_APPLE",
+        0x929C, "GL_SOFTLIGHT_KHR",
     },
     {
-     0x9118,
-     "GL_UNSIGNALED_APPLE",
+        0x846D, "GL_ALIASED_POINT_SIZE_RANGE",
     },
     {
-     0x9294,
-     "GL_MULTIPLY_KHR",
+        0x929E, "GL_DIFFERENCE_KHR",
     },
     {
-     0x9295,
-     "GL_SCREEN_KHR",
+        0x929F, "GL_MINUS_NV",
     },
     {
-     0x9296,
-     "GL_OVERLAY_KHR",
+        0x9282, "GL_UNCORRELATED_NV",
     },
     {
-     0x9297,
-     "GL_DARKEN_KHR",
+        0x9298, "GL_LIGHTEN_KHR",
     },
     {
-     0x0020,
-     "GL_MAP_UNSYNCHRONIZED_BIT_EXT",
+        0x9299, "GL_COLORDODGE_KHR",
     },
     {
-     0x8E78,
-     "GL_TESS_GEN_VERTEX_ORDER_EXT",
+        0x9111, "GL_MAX_SERVER_WAIT_TIMEOUT_APPLE",
     },
     {
-     0x8C01,
-     "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG",
+        0x93A6, "GL_PROGRAM_BINARY_ANGLE",
     },
     {
-     0x8C00,
-     "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG",
+        0x9117, "GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE",
     },
     {
-     0x8A52,
-     "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT",
+        0x93A0, "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE",
     },
     {
-     0x8C02,
-     "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG",
+        0x93A3, "GL_FRAMEBUFFER_ATTACHMENT_ANGLE",
     },
     {
-     0x84C9,
-     "GL_TEXTURE9",
+        0x93A2, "GL_TEXTURE_USAGE_ANGLE",
     },
     {
-     0x84C8,
-     "GL_TEXTURE8",
+        0x8802, "GL_STENCIL_BACK_PASS_DEPTH_FAIL",
     },
     {
-     0x8869,
-     "GL_MAX_VERTEX_ATTRIBS",
+        0x9119, "GL_SIGNALED_APPLE",
     },
     {
-     0x84C3,
-     "GL_TEXTURE3",
+        0x9118, "GL_UNSIGNALED_APPLE",
     },
     {
-     0x84C2,
-     "GL_TEXTURE2",
+        0x9294, "GL_MULTIPLY_KHR",
     },
     {
-     0x84C1,
-     "GL_TEXTURE1",
+        0x9295, "GL_SCREEN_KHR",
     },
     {
-     0x84C0,
-     "GL_TEXTURE0",
+        0x9296, "GL_OVERLAY_KHR",
     },
     {
-     0x84C7,
-     "GL_TEXTURE7",
+        0x9297, "GL_DARKEN_KHR",
     },
     {
-     0x84C6,
-     "GL_TEXTURE6",
+        0x0020, "GL_MAP_UNSYNCHRONIZED_BIT_EXT",
     },
     {
-     0x84C5,
-     "GL_TEXTURE5",
+        0x8E78, "GL_TESS_GEN_VERTEX_ORDER_EXT",
     },
     {
-     0x8803,
-     "GL_STENCIL_BACK_PASS_DEPTH_PASS",
+        0x8C01, "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG",
     },
     {
-     0x928A,
-     "GL_SRC_IN_NV",
+        0x8C00, "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG",
     },
     {
-     0x8518,
-     "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y",
+        0x8A52, "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT",
     },
     {
-     0x8519,
-     "GL_TEXTURE_CUBE_MAP_POSITIVE_Z",
+        0x8C02, "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG",
     },
     {
-     0x8514,
-     "GL_TEXTURE_BINDING_CUBE_MAP",
+        0x84C9, "GL_TEXTURE9",
     },
     {
-     0x8515,
-     "GL_TEXTURE_CUBE_MAP_POSITIVE_X",
+        0x84C8, "GL_TEXTURE8",
     },
     {
-     0x8516,
-     "GL_TEXTURE_CUBE_MAP_NEGATIVE_X",
+        0x8869, "GL_MAX_VERTEX_ATTRIBS",
     },
     {
-     0x8517,
-     "GL_TEXTURE_CUBE_MAP_POSITIVE_Y",
+        0x84C3, "GL_TEXTURE3",
     },
     {
-     0x8218,
-     "GL_FRAMEBUFFER_DEFAULT",
+        0x84C2, "GL_TEXTURE2",
     },
     {
-     0x8513,
-     "GL_TEXTURE_CUBE_MAP",
+        0x84C1, "GL_TEXTURE1",
     },
     {
-     0x8626,
-     "GL_CURRENT_VERTEX_ATTRIB",
+        0x84C0, "GL_TEXTURE0",
     },
     {
-     0x92B1,
-     "GL_PLUS_CLAMPED_NV",
+        0x84C7, "GL_TEXTURE7",
     },
     {
-     0x92B0,
-     "GL_HSL_LUMINOSITY_KHR",
+        0x84C6, "GL_TEXTURE6",
     },
     {
-     0x92B3,
-     "GL_MINUS_CLAMPED_NV",
+        0x84C5, "GL_TEXTURE5",
     },
     {
-     0x92B2,
-     "GL_PLUS_CLAMPED_ALPHA_NV",
+        0x8803, "GL_STENCIL_BACK_PASS_DEPTH_PASS",
     },
     {
-     0x8765,
-     "GL_BUFFER_USAGE",
+        0x928A, "GL_SRC_IN_NV",
     },
     {
-     0x8764,
-     "GL_BUFFER_SIZE",
+        0x8518, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y",
     },
     {
-     0x8B99,
-     "GL_PALETTE8_RGB5_A1_OES",
+        0x8519, "GL_TEXTURE_CUBE_MAP_POSITIVE_Z",
     },
     {
-     0x0503,
-     "GL_STACK_OVERFLOW_KHR",
+        0x8514, "GL_TEXTURE_BINDING_CUBE_MAP",
     },
     {
-     0x0502,
-     "GL_INVALID_OPERATION",
+        0x8515, "GL_TEXTURE_CUBE_MAP_POSITIVE_X",
     },
     {
-     0x0501,
-     "GL_INVALID_VALUE",
+        0x8516, "GL_TEXTURE_CUBE_MAP_NEGATIVE_X",
     },
     {
-     0x0500,
-     "GL_INVALID_ENUM",
+        0x8517, "GL_TEXTURE_CUBE_MAP_POSITIVE_Y",
     },
     {
-     0x0507,
-     "GL_CONTEXT_LOST_KHR",
+        0x8218, "GL_FRAMEBUFFER_DEFAULT",
     },
     {
-     0x0506,
-     "GL_INVALID_FRAMEBUFFER_OPERATION",
+        0x8513, "GL_TEXTURE_CUBE_MAP",
     },
     {
-     0x0505,
-     "GL_OUT_OF_MEMORY",
+        0x8626, "GL_CURRENT_VERTEX_ATTRIB",
     },
     {
-     0x0504,
-     "GL_STACK_UNDERFLOW_KHR",
+        0x92B1, "GL_PLUS_CLAMPED_NV",
     },
     {
-     0x0CF4,
-     "GL_UNPACK_SKIP_PIXELS_EXT",
+        0x92B0, "GL_HSL_LUMINOSITY_KHR",
     },
     {
-     0x0B44,
-     "GL_CULL_FACE",
+        0x92B3, "GL_MINUS_CLAMPED_NV",
     },
     {
-     0x8B5E,
-     "GL_SAMPLER_2D",
+        0x92B2, "GL_PLUS_CLAMPED_ALPHA_NV",
     },
     {
-     0x0B46,
-     "GL_FRONT_FACE",
+        0x8765, "GL_BUFFER_USAGE",
     },
     {
-     0x8FB3,
-     "GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM",
+        0x8764, "GL_BUFFER_SIZE",
     },
     {
-     0x824A,
-     "GL_DEBUG_SOURCE_APPLICATION_KHR",
+        0x8B99, "GL_PALETTE8_RGB5_A1_OES",
     },
     {
-     0x824B,
-     "GL_DEBUG_SOURCE_OTHER_KHR",
+        0x0503, "GL_STACK_OVERFLOW_KHR",
     },
     {
-     0x824C,
-     "GL_DEBUG_TYPE_ERROR_KHR",
+        0x0502, "GL_INVALID_OPERATION",
     },
     {
-     0x824D,
-     "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR",
+        0x0501, "GL_INVALID_VALUE",
     },
     {
-     0x824E,
-     "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR",
+        0x0500, "GL_INVALID_ENUM",
     },
     {
-     0x824F,
-     "GL_DEBUG_TYPE_PORTABILITY_KHR",
+        0x0507, "GL_CONTEXT_LOST_KHR",
     },
     {
-     0x8DD7,
-     "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY",
+        0x0506, "GL_INVALID_FRAMEBUFFER_OPERATION",
     },
     {
-     0x8B31,
-     "GL_VERTEX_SHADER",
+        0x0505, "GL_OUT_OF_MEMORY",
     },
     {
-     0x8B30,
-     "GL_FRAGMENT_SHADER",
+        0x0504, "GL_STACK_UNDERFLOW_KHR",
     },
     {
-     0x8FB1,
-     "GL_CPU_OPTIMIZED_QCOM",
+        0x0CF4, "GL_UNPACK_SKIP_PIXELS_EXT",
     },
     {
-     0x93D2,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR",
+        0x0B44, "GL_CULL_FACE",
     },
     {
-     0x82FB,
-     "GL_CONTEXT_RELEASE_BEHAVIOR_KHR",
+        0x8B5E, "GL_SAMPLER_2D",
     },
     {
-     0x8B5A,
-     "GL_FLOAT_MAT2",
+        0x0B46, "GL_FRONT_FACE",
     },
     {
-     0x84D8,
-     "GL_TEXTURE24",
+        0x8FB3, "GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM",
     },
     {
-     0x84D9,
-     "GL_TEXTURE25",
+        0x824A, "GL_DEBUG_SOURCE_APPLICATION_KHR",
     },
     {
-     0x84D6,
-     "GL_TEXTURE22",
+        0x824B, "GL_DEBUG_SOURCE_OTHER_KHR",
     },
     {
-     0x84D7,
-     "GL_TEXTURE23",
+        0x824C, "GL_DEBUG_TYPE_ERROR_KHR",
     },
     {
-     0x84D4,
-     "GL_TEXTURE20",
+        0x824D, "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR",
     },
     {
-     0x0D05,
-     "GL_PACK_ALIGNMENT",
+        0x824E, "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR",
     },
     {
-     0x84D2,
-     "GL_TEXTURE18",
+        0x824F, "GL_DEBUG_TYPE_PORTABILITY_KHR",
     },
     {
-     0x84D3,
-     "GL_TEXTURE19",
+        0x8DD7, "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY",
     },
     {
-     0x84D0,
-     "GL_TEXTURE16",
+        0x8B31, "GL_VERTEX_SHADER",
     },
     {
-     0x84D1,
-     "GL_TEXTURE17",
+        0x8B30, "GL_FRAGMENT_SHADER",
     },
     {
-     0x93D1,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR",
+        0x8FB1, "GL_CPU_OPTIMIZED_QCOM",
     },
     {
-     0x84DF,
-     "GL_TEXTURE31",
+        0x93D2, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR",
     },
     {
-     0x8B97,
-     "GL_PALETTE8_R5_G6_B5_OES",
+        0x82FB, "GL_CONTEXT_RELEASE_BEHAVIOR_KHR",
     },
     {
-     0x84DD,
-     "GL_TEXTURE29",
+        0x8B5A, "GL_FLOAT_MAT2",
     },
     {
-     0x84DE,
-     "GL_TEXTURE30",
+        0x84D8, "GL_TEXTURE24",
     },
     {
-     0x84DB,
-     "GL_TEXTURE27",
+        0x84D9, "GL_TEXTURE25",
     },
     {
-     0x84DC,
-     "GL_TEXTURE28",
+        0x84D6, "GL_TEXTURE22",
     },
     {
-     0x6002,
-     "GL_TEXTURE_POOL_UNMANAGED_CHROMIUM",
+        0x84D7, "GL_TEXTURE23",
     },
     {
-     0x84DA,
-     "GL_TEXTURE26",
+        0x84D4, "GL_TEXTURE20",
     },
     {
-     0x8242,
-     "GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR",
+        0x0D05, "GL_PACK_ALIGNMENT",
     },
     {
-     0x8243,
-     "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR",
+        0x84D2, "GL_TEXTURE18",
     },
     {
-     0x8244,
-     "GL_DEBUG_CALLBACK_FUNCTION_KHR",
+        0x84D3, "GL_TEXTURE19",
     },
     {
-     0x8245,
-     "GL_DEBUG_CALLBACK_USER_PARAM_KHR",
+        0x84D0, "GL_TEXTURE16",
     },
     {
-     0x8246,
-     "GL_DEBUG_SOURCE_API_KHR",
+        0x84D1, "GL_TEXTURE17",
     },
     {
-     0x8247,
-     "GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR",
+        0x93D1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR",
     },
     {
-     0x8248,
-     "GL_DEBUG_SOURCE_SHADER_COMPILER_KHR",
+        0x84DF, "GL_TEXTURE31",
     },
     {
-     0x8249,
-     "GL_DEBUG_SOURCE_THIRD_PARTY_KHR",
+        0x8B97, "GL_PALETTE8_R5_G6_B5_OES",
     },
     {
-     0x88ED,
-     "GL_PIXEL_PACK_BUFFER_BINDING",
+        0x84DD, "GL_TEXTURE29",
     },
     {
-     0x8B94,
-     "GL_PALETTE4_RGB5_A1_OES",
+        0x84DE, "GL_TEXTURE30",
     },
     {
-     0x94F4,
-     "GL_PERFQUERY_COUNTER_RAW_INTEL",
+        0x84DB, "GL_TEXTURE27",
     },
     {
-     0x823C,
-     "GL_RG32UI",
+        0x84DC, "GL_TEXTURE28",
     },
     {
-     0x8A29,
-     "GL_UNIFORM_BUFFER_START",
+        0x6002, "GL_TEXTURE_POOL_UNMANAGED_CHROMIUM",
     },
     {
-     0x8A28,
-     "GL_UNIFORM_BUFFER_BINDING",
+        0x84DA, "GL_TEXTURE26",
     },
     {
-     0x92BE,
-     "GL_PRIMITIVE_BOUNDING_BOX_EXT",
+        0x8242, "GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR",
     },
     {
-     0x8645,
-     "GL_VERTEX_ATTRIB_ARRAY_POINTER",
+        0x8243, "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR",
     },
     {
-     0x8865,
-     "GL_CURRENT_QUERY_EXT",
+        0x8244, "GL_DEBUG_CALLBACK_FUNCTION_KHR",
     },
     {
-     0x9380,
-     "GL_NUM_SAMPLE_COUNTS",
+        0x8245, "GL_DEBUG_CALLBACK_USER_PARAM_KHR",
     },
     {
-     0x8E5B,
-     "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES",
+        0x8246, "GL_DEBUG_SOURCE_API_KHR",
     },
     {
-     0x8E5C,
-     "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES",
+        0x8247, "GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR",
     },
     {
-     0x8E5D,
-     "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES",
+        0x8248, "GL_DEBUG_SOURCE_SHADER_COMPILER_KHR",
     },
     {
-     0x906A,
-     "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT",
+        0x8249, "GL_DEBUG_SOURCE_THIRD_PARTY_KHR",
     },
     {
-     0x906F,
-     "GL_RGB10_A2UI",
+        0x88ED, "GL_PIXEL_PACK_BUFFER_BINDING",
     },
     {
-     0x8E72,
-     "GL_PATCH_VERTICES_EXT",
+        0x8B94, "GL_PALETTE4_RGB5_A1_OES",
     },
     {
-     0x8BD3,
-     "GL_TEXTURE_HEIGHT_QCOM",
+        0x94F4, "GL_PERFQUERY_COUNTER_RAW_INTEL",
     },
     {
-     0x87FA,
-     "GL_3DC_XY_AMD",
+        0x823C, "GL_RG32UI",
     },
     {
-     0x84C4,
-     "GL_TEXTURE4",
+        0x8A29, "GL_UNIFORM_BUFFER_START",
     },
     {
-     0x821C,
-     "GL_MINOR_VERSION",
+        0x8A28, "GL_UNIFORM_BUFFER_BINDING",
     },
     {
-     0x8E8A,
-     "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT",
+        0x92BE, "GL_PRIMITIVE_BOUNDING_BOX_EXT",
     },
     {
-     0x85B5,
-     "GL_VERTEX_ARRAY_BINDING_OES",
+        0x8645, "GL_VERTEX_ATTRIB_ARRAY_POINTER",
     },
     {
-     0x8253,
-     "GL_GUILTY_CONTEXT_RESET_KHR",
+        0x8865, "GL_CURRENT_QUERY_EXT",
     },
     {
-     0x8D6B,
-     "GL_MAX_ELEMENT_INDEX",
+        0x9380, "GL_NUM_SAMPLE_COUNTS",
     },
     {
-     0x8D6C,
-     "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT",
+        0x8E5B, "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES",
     },
     {
-     0x92A1,
-     "GL_CONTRAST_NV",
+        0x8E5C, "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES",
     },
     {
-     0x8252,
-     "GL_LOSE_CONTEXT_ON_RESET_KHR",
+        0x8E5D, "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES",
     },
     {
-     0x8C4C,
-     "GL_COMPRESSED_SRGB_S3TC_DXT1_NV",
+        0x906A, "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT",
     },
     {
-     0x8C4E,
-     "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV",
+        0x906F, "GL_RGB10_A2UI",
     },
     {
-     0x8251,
-     "GL_DEBUG_TYPE_OTHER_KHR",
+        0x8E72, "GL_PATCH_VERTICES_EXT",
     },
     {
-     0x8C4F,
-     "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV",
+        0x8BD3, "GL_TEXTURE_HEIGHT_QCOM",
     },
     {
-     0x9309,
-     "GL_REFERENCED_BY_GEOMETRY_SHADER_EXT",
+        0x87FA, "GL_3DC_XY_AMD",
     },
     {
-     0x93E9,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES",
+        0x84C4, "GL_TEXTURE4",
     },
     {
-     0x93E8,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES",
+        0x1A, "GL_CONIC_CURVE_TO_CHROMIUM",
     },
     {
-     0x8C43,
-     "GL_SRGB8_ALPHA8_EXT",
+        0x821C, "GL_MINOR_VERSION",
     },
     {
-     0x8C42,
-     "GL_SRGB_ALPHA_EXT",
+        0x8E8A, "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT",
     },
     {
-     0x8C45,
-     "GL_SLUMINANCE8_ALPHA8_NV",
+        0x85B5, "GL_VERTEX_ARRAY_BINDING_OES",
     },
     {
-     0x8C44,
-     "GL_SLUMINANCE_ALPHA_NV",
+        0x8253, "GL_GUILTY_CONTEXT_RESET_KHR",
     },
     {
-     0x8C47,
-     "GL_SLUMINANCE8_NV",
+        0x8D6B, "GL_MAX_ELEMENT_INDEX",
     },
     {
-     0x8C46,
-     "GL_SLUMINANCE_NV",
+        0x8D6C, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT",
     },
     {
-     0x93E1,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES",
+        0x92A1, "GL_CONTRAST_NV",
     },
     {
-     0x93E0,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES",
+        0x8252, "GL_LOSE_CONTEXT_ON_RESET_KHR",
     },
     {
-     0x93E3,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES",
+        0x8C4C, "GL_COMPRESSED_SRGB_S3TC_DXT1_NV",
     },
     {
-     0x93E2,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES",
+        0x8C4E, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV",
     },
     {
-     0x93E5,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES",
+        0x8251, "GL_DEBUG_TYPE_OTHER_KHR",
     },
     {
-     0x93E4,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES",
+        0x8C4F, "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV",
     },
     {
-     0x93E7,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES",
+        0x9309, "GL_REFERENCED_BY_GEOMETRY_SHADER_EXT",
     },
     {
-     0x93E6,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES",
+        0x93E9, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES",
     },
     {
-     0x8D68,
-     "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES",
+        0x93E8, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES",
     },
     {
-     0x8E82,
-     "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT",
+        0x8C43, "GL_SRGB8_ALPHA8_EXT",
     },
     {
-     0x8E81,
-     "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT",
+        0x8C42, "GL_SRGB_ALPHA_EXT",
     },
     {
-     0x85BB,
-     "GL_UNSIGNED_SHORT_8_8_REV_APPLE",
+        0x8C45, "GL_SLUMINANCE8_ALPHA8_NV",
     },
     {
-     0x8E87,
-     "GL_TESS_EVALUATION_SHADER_EXT",
+        0x8C44, "GL_SLUMINANCE_ALPHA_NV",
     },
     {
-     0x8E86,
-     "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT",
+        0x8C47, "GL_SLUMINANCE8_NV",
     },
     {
-     0x8E85,
-     "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT",
+        0x8C46, "GL_SLUMINANCE_NV",
     },
     {
-     0x8E84,
-     "GL_MAX_TESS_PATCH_COMPONENTS_EXT",
+        0x93E1, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES",
     },
     {
-     0x8D61,
-     "GL_HALF_FLOAT_OES",
+        0x93E0, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES",
     },
     {
-     0x8D62,
-     "GL_RGB565",
+        0x93E3, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES",
     },
     {
-     0x8E88,
-     "GL_TESS_CONTROL_SHADER_EXT",
+        0x93E2, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES",
     },
     {
-     0x8D64,
-     "GL_ETC1_RGB8_OES",
+        0x93E5, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES",
     },
     {
-     0x8D65,
-     "GL_TEXTURE_EXTERNAL_OES",
+        0x93E4, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES",
     },
     {
-     0x8D66,
-     "GL_SAMPLER_EXTERNAL_OES",
+        0x93E7, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES",
     },
     {
-     0x8D67,
-     "GL_TEXTURE_BINDING_EXTERNAL_OES",
+        0x93E6, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES",
     },
     {
-     0x10000000,
-     "GL_MULTISAMPLE_BUFFER_BIT4_QCOM",
+        0x8D68, "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES",
     },
     {
-     0x04000000,
-     "GL_MULTISAMPLE_BUFFER_BIT2_QCOM",
+        0x8E82, "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT",
     },
     {
-     0x90D7,
-     "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT",
+        0x8E81, "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT",
     },
     {
-     0x90D9,
-     "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT",
+        0x85BB, "GL_UNSIGNED_SHORT_8_8_REV_APPLE",
     },
     {
-     0x90D8,
-     "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT",
+        0x8E87, "GL_TESS_EVALUATION_SHADER_EXT",
     },
     {
-     0x8CEE,
-     "GL_COLOR_ATTACHMENT14_EXT",
+        0x8E86, "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT",
     },
     {
-     0x8DC7,
-     "GL_UNSIGNED_INT_VEC3",
+        0x8E85, "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT",
     },
     {
-     0x1701,
-     "GL_PATH_PROJECTION_CHROMIUM",
+        0x8E84, "GL_MAX_TESS_PATCH_COMPONENTS_EXT",
     },
     {
-     0x2800,
-     "GL_TEXTURE_MAG_FILTER",
+        0x8D61, "GL_HALF_FLOAT_OES",
     },
     {
-     0x2801,
-     "GL_TEXTURE_MIN_FILTER",
+        0x8D62, "GL_RGB565",
     },
     {
-     0x2802,
-     "GL_TEXTURE_WRAP_S",
+        0x8E88, "GL_TESS_CONTROL_SHADER_EXT",
     },
     {
-     0x2803,
-     "GL_TEXTURE_WRAP_T",
+        0x8D64, "GL_ETC1_RGB8_OES",
     },
     {
-     0x8DCB,
-     "GL_INT_SAMPLER_3D",
+        0x8D65, "GL_TEXTURE_EXTERNAL_OES",
     },
     {
-     0x3007,
-     "GL_CLIP_DISTANCE7_APPLE",
+        0x8D66, "GL_SAMPLER_EXTERNAL_OES",
     },
     {
-     0x2703,
-     "GL_LINEAR_MIPMAP_LINEAR",
+        0x8D67, "GL_TEXTURE_BINDING_EXTERNAL_OES",
     },
     {
-     0x3005,
-     "GL_CLIP_DISTANCE5_APPLE",
+        0x10000000, "GL_MULTISAMPLE_BUFFER_BIT4_QCOM",
     },
     {
-     0x3004,
-     "GL_CLIP_DISTANCE4_APPLE",
+        0x04000000, "GL_MULTISAMPLE_BUFFER_BIT2_QCOM",
     },
     {
-     0x8B98,
-     "GL_PALETTE8_RGBA4_OES",
+        0x90D7, "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT",
     },
     {
-     0x3002,
-     "GL_CLIP_DISTANCE2_APPLE",
+        0x90D9, "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT",
     },
     {
-     0x3001,
-     "GL_CLIP_DISTANCE1_APPLE",
+        0x90D8, "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT",
     },
     {
-     0x2702,
-     "GL_NEAREST_MIPMAP_LINEAR",
+        0x8CEE, "GL_COLOR_ATTACHMENT14_EXT",
     },
     {
-     0x1F03,
-     "GL_EXTENSIONS",
+        0x8DC7, "GL_UNSIGNED_INT_VEC3",
     },
     {
-     0x1F02,
-     "GL_VERSION",
+        0x1701, "GL_PATH_PROJECTION_CHROMIUM",
     },
     {
-     0x1F01,
-     "GL_RENDERER",
+        0x2800, "GL_TEXTURE_MAG_FILTER",
     },
     {
-     0x1F00,
-     "GL_VENDOR",
+        0x2801, "GL_TEXTURE_MIN_FILTER",
     },
     {
-     0x9247,
-     "GL_OVERLAY_TRANSFORM_FLIP_VERTICAL_CHROMIUM",
+        0x2802, "GL_TEXTURE_WRAP_S",
     },
     {
-     0x2701,
-     "GL_LINEAR_MIPMAP_NEAREST",
+        0x2803, "GL_TEXTURE_WRAP_T",
     },
     {
-     0x9245,
-     "GL_OVERLAY_TRANSFORM_NONE_CHROMIUM",
+        0x8DCB, "GL_INT_SAMPLER_3D",
     },
     {
-     0x92B4,
-     "GL_INVERT_OVG_NV",
+        0x3007, "GL_CLIP_DISTANCE7_APPLE",
     },
     {
-     0x9249,
-     "GL_OVERLAY_TRANSFORM_ROTATE_180_CHROMIUM",
+        0x2703, "GL_LINEAR_MIPMAP_LINEAR",
     },
     {
-     0x0B94,
-     "GL_STENCIL_FAIL",
+        0x3005, "GL_CLIP_DISTANCE5_APPLE",
     },
     {
-     0x8B4A,
-     "GL_MAX_VERTEX_UNIFORM_COMPONENTS",
+        0x3004, "GL_CLIP_DISTANCE4_APPLE",
     },
     {
-     0x8B4B,
-     "GL_MAX_VARYING_COMPONENTS",
+        0x8B98, "GL_PALETTE8_RGBA4_OES",
     },
     {
-     0x8B4C,
-     "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS",
+        0x3002, "GL_CLIP_DISTANCE2_APPLE",
     },
     {
-     0x8B4D,
-     "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS",
+        0x3001, "GL_CLIP_DISTANCE1_APPLE",
     },
     {
-     0x8B4F,
-     "GL_SHADER_TYPE",
+        0x2702, "GL_NEAREST_MIPMAP_LINEAR",
     },
     {
-     0x9122,
-     "GL_MAX_VERTEX_OUTPUT_COMPONENTS",
+        0x1F03, "GL_EXTENSIONS",
     },
     {
-     0x9123,
-     "GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT",
+        0x1F02, "GL_VERSION",
     },
     {
-     0x83FB,
-     "GL_PERFQUERY_WAIT_INTEL",
+        0x1F01, "GL_RENDERER",
     },
     {
-     0x9121,
-     "GL_BUFFER_MAP_OFFSET",
+        0x1F00, "GL_VENDOR",
     },
     {
-     0x00004000,
-     "GL_COLOR_BUFFER_BIT",
+        0x9247, "GL_OVERLAY_TRANSFORM_FLIP_VERTICAL_CHROMIUM",
     },
     {
-     0x9125,
-     "GL_MAX_FRAGMENT_INPUT_COMPONENTS",
+        0x2701, "GL_LINEAR_MIPMAP_NEAREST",
     },
     {
-     0x00000010,
-     "GL_TESS_EVALUATION_SHADER_BIT_EXT",
+        0x9245, "GL_OVERLAY_TRANSFORM_NONE_CHROMIUM",
     },
     {
-     0x8834,
-     "GL_DRAW_BUFFER15_EXT",
+        0x92B4, "GL_INVERT_OVG_NV",
     },
     {
-     0x8833,
-     "GL_DRAW_BUFFER14_EXT",
+        0x9249, "GL_OVERLAY_TRANSFORM_ROTATE_180_CHROMIUM",
     },
     {
-     0x8832,
-     "GL_DRAW_BUFFER13_EXT",
+        0x0B94, "GL_STENCIL_FAIL",
     },
     {
-     0x8831,
-     "GL_DRAW_BUFFER12_EXT",
+        0x8B4A, "GL_MAX_VERTEX_UNIFORM_COMPONENTS",
     },
     {
-     0x8830,
-     "GL_DRAW_BUFFER11_EXT",
+        0x8B4B, "GL_MAX_VARYING_COMPONENTS",
     },
     {
-     0x8DC5,
-     "GL_SAMPLER_CUBE_SHADOW_NV",
+        0x8B4C, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS",
     },
     {
-     0x94FF,
-     "GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL",
+        0x8B4D, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS",
     },
     {
-     0x94FE,
-     "GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL",
+        0x8B4F, "GL_SHADER_TYPE",
     },
     {
-     0x94FD,
-     "GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL",
+        0x9122, "GL_MAX_VERTEX_OUTPUT_COMPONENTS",
     },
     {
-     0x94FC,
-     "GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL",
+        0x9123, "GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT",
     },
     {
-     0x94FB,
-     "GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL",
+        0x83FB, "GL_PERFQUERY_WAIT_INTEL",
     },
     {
-     0x93B8,
-     "GL_COMPRESSED_RGBA_ASTC_10x5_KHR",
+        0x9121, "GL_BUFFER_MAP_OFFSET",
     },
     {
-     0x8B65,
-     "GL_FLOAT_MAT2x3_NV",
+        0x9089, "GL_COUNT_DOWN_CHROMIUM",
     },
     {
-     0x9241,
-     "GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM",
+        0x9088, "GL_COUNT_UP_CHROMIUM",
     },
     {
-     0x00010000,
-     "GL_STENCIL_BUFFER_BIT0_QCOM",
+        0x00004000, "GL_COLOR_BUFFER_BIT",
     },
     {
-     0x83FA,
-     "GL_PERFQUERY_FLUSH_INTEL",
+        0x9125, "GL_MAX_FRAGMENT_INPUT_COMPONENTS",
     },
     {
-     0x0D03,
-     "GL_PACK_SKIP_ROWS",
+        0x00000010, "GL_TESS_EVALUATION_SHADER_BIT_EXT",
     },
     {
-     0x84F3,
-     "GL_FENCE_STATUS_NV",
+        0x8834, "GL_DRAW_BUFFER15_EXT",
     },
     {
-     0x88E6,
-     "GL_STATIC_COPY",
+        0x8833, "GL_DRAW_BUFFER14_EXT",
     },
     {
-     0x0B93,
-     "GL_STENCIL_VALUE_MASK",
+        0x8832, "GL_DRAW_BUFFER13_EXT",
     },
     {
-     0x0B92,
-     "GL_STENCIL_FUNC",
+        0x8831, "GL_DRAW_BUFFER12_EXT",
     },
     {
-     0x0B91,
-     "GL_STENCIL_CLEAR_VALUE",
+        0x8830, "GL_DRAW_BUFFER11_EXT",
     },
     {
-     0x883D,
-     "GL_BLEND_EQUATION_ALPHA",
+        0x8DC5, "GL_SAMPLER_CUBE_SHADOW_NV",
     },
     {
-     0x0B97,
-     "GL_STENCIL_REF",
+        0x94FF, "GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL",
     },
     {
-     0x0B96,
-     "GL_STENCIL_PASS_DEPTH_PASS",
+        0x94FE, "GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL",
     },
     {
-     0x0B95,
-     "GL_STENCIL_PASS_DEPTH_FAIL",
+        0x94FD, "GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL",
     },
     {
-     0x2700,
-     "GL_NEAREST_MIPMAP_NEAREST",
+        0x94FC, "GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL",
     },
     {
-     0x94F5,
-     "GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL",
+        0x94FB, "GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL",
     },
     {
-     0x0B98,
-     "GL_STENCIL_WRITEMASK",
+        0x93B8, "GL_COMPRESSED_RGBA_ASTC_10x5_KHR",
     },
     {
-     0x94F3,
-     "GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL",
+        0x8B65, "GL_FLOAT_MAT2x3_NV",
     },
     {
-     0x94F2,
-     "GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL",
+        0x00010000, "GL_STENCIL_BUFFER_BIT0_QCOM",
     },
     {
-     0x94F1,
-     "GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL",
+        0x83FA, "GL_PERFQUERY_FLUSH_INTEL",
     },
     {
-     0x94F0,
-     "GL_PERFQUERY_COUNTER_EVENT_INTEL",
+        0x0D03, "GL_PACK_SKIP_ROWS",
     },
     {
-     0x8B40,
-     "GL_PROGRAM_OBJECT_EXT",
+        0x84F3, "GL_FENCE_STATUS_NV",
     },
     {
-     0x1004,
-     "GL_TEXTURE_BORDER_COLOR_EXT",
+        0x908D, "GL_BOUNDING_BOX_CHROMIUM",
     },
     {
-     0x8A2D,
-     "GL_MAX_FRAGMENT_UNIFORM_BLOCKS",
+        0x88E6, "GL_STATIC_COPY",
     },
     {
-     0x8B48,
-     "GL_SHADER_OBJECT_EXT",
+        0x0B93, "GL_STENCIL_VALUE_MASK",
     },
     {
-     0x8B49,
-     "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS",
+        0x0B92, "GL_STENCIL_FUNC",
     },
     {
-     0x813A,
-     "GL_TEXTURE_MIN_LOD",
+        0x0B91, "GL_STENCIL_CLEAR_VALUE",
     },
     {
-     0x8DE1,
-     "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT",
+        0x883D, "GL_BLEND_EQUATION_ALPHA",
     },
     {
-     0x8DE0,
-     "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT",
+        0x0B97, "GL_STENCIL_REF",
     },
     {
-     0x924C,
-     "GL_MOUSE_POSITION_CHROMIUM",
+        0x0B96, "GL_STENCIL_PASS_DEPTH_PASS",
     },
     {
-     0x924B,
-     "GL_SUBSCRIBED_VALUES_BUFFER_CHROMIUM",
+        0x0B95, "GL_STENCIL_PASS_DEPTH_FAIL",
     },
     {
-     0x924A,
-     "GL_OVERLAY_TRANSFORM_ROTATE_270_CHROMIUM",
+        0x2700, "GL_NEAREST_MIPMAP_NEAREST",
     },
     {
-     0x8A2F,
-     "GL_MAX_UNIFORM_BUFFER_BINDINGS",
+        0x94F5, "GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL",
     },
     {
-     0x20000000,
-     "GL_MULTISAMPLE_BUFFER_BIT5_QCOM",
+        0x0B98, "GL_STENCIL_WRITEMASK",
     },
     {
-     64,
-     "GL_MAILBOX_SIZE_CHROMIUM",
+        0x94F3, "GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL",
     },
     {
-     0x0DE1,
-     "GL_TEXTURE_2D",
+        0x94F2, "GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL",
     },
     {
-     0x8A2C,
-     "GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT",
+        0x94F1, "GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL",
     },
     {
-     0x80C9,
-     "GL_BLEND_SRC_RGB",
+        0x94F0, "GL_PERFQUERY_COUNTER_EVENT_INTEL",
     },
     {
-     0x80C8,
-     "GL_BLEND_DST_RGB",
+        0x8B40, "GL_PROGRAM_OBJECT_EXT",
     },
     {
-     0x912F,
-     "GL_TEXTURE_IMMUTABLE_FORMAT_EXT",
+        0x1004, "GL_TEXTURE_BORDER_COLOR_EXT",
     },
     {
-     0x8A2B,
-     "GL_MAX_VERTEX_UNIFORM_BLOCKS",
+        0x908B, "GL_CONVEX_HULL_CHROMIUM",
     },
     {
-     0x88EC,
-     "GL_PIXEL_UNPACK_BUFFER",
+        0x8B48, "GL_SHADER_OBJECT_EXT",
     },
     {
-     0x8D8F,
-     "GL_RGB8I",
+        0x8B49, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS",
     },
     {
-     0x8059,
-     "GL_RGB10_A2_EXT",
+        0x813A, "GL_TEXTURE_MIN_LOD",
     },
     {
-     0x8058,
-     "GL_RGBA8_OES",
+        0x8DE1, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT",
     },
     {
-     0x8B93,
-     "GL_PALETTE4_RGBA4_OES",
+        0x8DE0, "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT",
     },
     {
-     0x88EB,
-     "GL_PIXEL_PACK_BUFFER",
+        0x924C, "GL_MOUSE_POSITION_CHROMIUM",
     },
     {
-     0x8E83,
-     "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT",
+        0x924B, "GL_SUBSCRIBED_VALUES_BUFFER_CHROMIUM",
     },
     {
-     0x8051,
-     "GL_RGB8_OES",
+        0x924A, "GL_OVERLAY_TRANSFORM_ROTATE_270_CHROMIUM",
     },
     {
-     0x8CAD,
-     "GL_DEPTH32F_STENCIL8",
+        0x8A2F, "GL_MAX_UNIFORM_BUFFER_BINDINGS",
     },
     {
-     0x8052,
-     "GL_RGB10_EXT",
+        0x20000000, "GL_MULTISAMPLE_BUFFER_BIT5_QCOM",
     },
     {
-     0x8CAB,
-     "GL_RENDERBUFFER_SAMPLES_ANGLE",
+        64, "GL_MAILBOX_SIZE_CHROMIUM",
     },
     {
-     0x8CAC,
-     "GL_DEPTH_COMPONENT32F",
+        0x0DE1, "GL_TEXTURE_2D",
     },
     {
-     0x8057,
-     "GL_RGB5_A1",
+        0x8A2C, "GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT",
     },
     {
-     0x8056,
-     "GL_RGBA4",
+        0x80C9, "GL_BLEND_SRC_RGB",
     },
     {
-     0x8232,
-     "GL_R8UI",
+        0x80C8, "GL_BLEND_DST_RGB",
     },
     {
-     0x150A,
-     "GL_INVERT",
+        0x912F, "GL_TEXTURE_IMMUTABLE_FORMAT_EXT",
     },
     {
-     0x01000000,
-     "GL_MULTISAMPLE_BUFFER_BIT0_QCOM",
+        0x8A2B, "GL_MAX_VERTEX_UNIFORM_BLOCKS",
     },
     {
-     0x78ED,
-     "GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM",
+        0x88EC, "GL_PIXEL_UNPACK_BUFFER",
     },
     {
-     0x78EE,
-     "GL_PIXEL_PACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
+        0x8D8F, "GL_RGB8I",
     },
     {
-     0x6001,
-     "GL_TEXTURE_POOL_MANAGED_CHROMIUM",
+        0x8059, "GL_RGB10_A2_EXT",
     },
     {
-     0x0B45,
-     "GL_CULL_FACE_MODE",
+        0x8058, "GL_RGBA8_OES",
     },
     {
-     0x8B92,
-     "GL_PALETTE4_R5_G6_B5_OES",
+        0x8B93, "GL_PALETTE4_RGBA4_OES",
     },
     {
-     0x00100000,
-     "GL_STENCIL_BUFFER_BIT4_QCOM",
+        0x88EB, "GL_PIXEL_PACK_BUFFER",
     },
     {
-     0x8E4E,
-     "GL_LAST_VERTEX_CONVENTION_EXT",
+        0x8E83, "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT",
     },
     {
-     0x8E4D,
-     "GL_FIRST_VERTEX_CONVENTION_EXT",
+        0x8051, "GL_RGB8_OES",
     },
     {
-     0x8E24,
-     "GL_TRANSFORM_FEEDBACK_ACTIVE",
+        0x8CAD, "GL_DEPTH32F_STENCIL8",
     },
     {
-     0x8E45,
-     "GL_TEXTURE_SWIZZLE_A",
+        0x8052, "GL_RGB10_EXT",
     },
     {
-     0x8E44,
-     "GL_TEXTURE_SWIZZLE_B",
+        0x8CAB, "GL_RENDERBUFFER_SAMPLES_ANGLE",
     },
     {
-     0x8E43,
-     "GL_TEXTURE_SWIZZLE_G",
+        0x8CAC, "GL_DEPTH_COMPONENT32F",
     },
     {
-     0x8E42,
-     "GL_TEXTURE_SWIZZLE_R",
+        0x8057, "GL_RGB5_A1",
     },
     {
-     0x8D20,
-     "GL_STENCIL_ATTACHMENT",
+        0x8056, "GL_RGBA4",
     },
     {
-     0x8B91,
-     "GL_PALETTE4_RGBA8_OES",
+        0x8232, "GL_R8UI",
     },
     {
-     0x00000200,
-     "GL_DEPTH_BUFFER_BIT1_QCOM",
+        0x90A4, "GL_ROUND_CHROMIUM",
     },
     {
-     0x00008000,
-     "GL_COVERAGE_BUFFER_BIT_NV",
+        0x150A, "GL_INVERT",
     },
     {
-     0x1506,
-     "GL_XOR_NV",
+        0x01000000, "GL_MULTISAMPLE_BUFFER_BIT0_QCOM",
     },
     {
-     0x8CA8,
-     "GL_READ_FRAMEBUFFER_ANGLE",
+        0x78ED, "GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM",
     },
     {
-     0x8CA9,
-     "GL_DRAW_FRAMEBUFFER_ANGLE",
+        0x78EE, "GL_PIXEL_PACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
     },
     {
-     0x8CA6,
-     "GL_FRAMEBUFFER_BINDING",
+        0x6001, "GL_TEXTURE_POOL_MANAGED_CHROMIUM",
     },
     {
-     0x8CA7,
-     "GL_RENDERBUFFER_BINDING",
+        0x0B45, "GL_CULL_FACE_MODE",
     },
     {
-     0x8CA4,
-     "GL_STENCIL_BACK_VALUE_MASK",
+        0x8B92, "GL_PALETTE4_R5_G6_B5_OES",
     },
     {
-     0x8CA5,
-     "GL_STENCIL_BACK_WRITEMASK",
+        0x00100000, "GL_STENCIL_BUFFER_BIT4_QCOM",
     },
     {
-     0x8B90,
-     "GL_PALETTE4_RGB8_OES",
+        0x8E4E, "GL_LAST_VERTEX_CONVENTION_EXT",
     },
     {
-     0x8CA3,
-     "GL_STENCIL_BACK_REF",
+        0x8E4D, "GL_FIRST_VERTEX_CONVENTION_EXT",
     },
     {
-     0x80E8,
-     "GL_MAX_ELEMENTS_VERTICES",
+        0x8E24, "GL_TRANSFORM_FEEDBACK_ACTIVE",
     },
     {
-     0x80CB,
-     "GL_BLEND_SRC_ALPHA",
+        0x8E45, "GL_TEXTURE_SWIZZLE_A",
     },
     {
-     0x80CA,
-     "GL_BLEND_DST_ALPHA",
+        0x8E44, "GL_TEXTURE_SWIZZLE_B",
     },
     {
-     0x8CE7,
-     "GL_COLOR_ATTACHMENT7_EXT",
+        0x8E43, "GL_TEXTURE_SWIZZLE_G",
     },
     {
-     0x93B0,
-     "GL_COMPRESSED_RGBA_ASTC_4x4_KHR",
+        0x8E42, "GL_TEXTURE_SWIZZLE_R",
     },
     {
-     0x93B1,
-     "GL_COMPRESSED_RGBA_ASTC_5x4_KHR",
+        0x8D20, "GL_STENCIL_ATTACHMENT",
     },
     {
-     0x93B2,
-     "GL_COMPRESSED_RGBA_ASTC_5x5_KHR",
+        0x8B91, "GL_PALETTE4_RGBA8_OES",
     },
     {
-     0x93B3,
-     "GL_COMPRESSED_RGBA_ASTC_6x5_KHR",
+        0x00000200, "GL_DEPTH_BUFFER_BIT1_QCOM",
     },
     {
-     0x93B4,
-     "GL_COMPRESSED_RGBA_ASTC_6x6_KHR",
+        0x8C85, "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE",
     },
     {
-     0x93B5,
-     "GL_COMPRESSED_RGBA_ASTC_8x5_KHR",
+        0x00008000, "GL_COVERAGE_BUFFER_BIT_NV",
     },
     {
-     0x93B6,
-     "GL_COMPRESSED_RGBA_ASTC_8x6_KHR",
+        0x1506, "GL_XOR_NV",
     },
     {
-     0x93B7,
-     "GL_COMPRESSED_RGBA_ASTC_8x8_KHR",
+        0x8CA8, "GL_READ_FRAMEBUFFER_ANGLE",
     },
     {
-     0x8CD6,
-     "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",
+        0x8CA9, "GL_DRAW_FRAMEBUFFER_ANGLE",
     },
     {
-     0x93B9,
-     "GL_COMPRESSED_RGBA_ASTC_10x6_KHR",
+        0x8CA6, "GL_FRAMEBUFFER_BINDING",
     },
     {
-     0x80E9,
-     "GL_MAX_ELEMENTS_INDICES",
+        0x8CA7, "GL_RENDERBUFFER_BINDING",
     },
     {
-     0x8CE5,
-     "GL_COLOR_ATTACHMENT5_EXT",
+        0x8CA4, "GL_STENCIL_BACK_VALUE_MASK",
     },
     {
-     0x8C84,
-     "GL_TRANSFORM_FEEDBACK_BUFFER_START",
+        0x8CA5, "GL_STENCIL_BACK_WRITEMASK",
     },
     {
-     0x8DC2,
-     "GL_SAMPLER_BUFFER_EXT",
+        0x8B90, "GL_PALETTE4_RGB8_OES",
     },
     {
-     0x8C36,
-     "GL_SAMPLE_SHADING_OES",
+        0x8CA3, "GL_STENCIL_BACK_REF",
     },
     {
-     0x8C37,
-     "GL_MIN_SAMPLE_SHADING_VALUE_OES",
+        0x80E8, "GL_MAX_ELEMENTS_VERTICES",
     },
     {
-     0x8F97,
-     "GL_RGBA8_SNORM",
+        0x80CB, "GL_BLEND_SRC_ALPHA",
     },
     {
-     0x8CE9,
-     "GL_COLOR_ATTACHMENT9_EXT",
+        0x80CA, "GL_BLEND_DST_ALPHA",
     },
     {
-     0x8DAD,
-     "GL_FLOAT_32_UNSIGNED_INT_24_8_REV",
+        0x8CE7, "GL_COLOR_ATTACHMENT7_EXT",
     },
     {
-     0x8B96,
-     "GL_PALETTE8_RGBA8_OES",
+        0x93B0, "GL_COMPRESSED_RGBA_ASTC_4x4_KHR",
     },
     {
-     0x8872,
-     "GL_MAX_TEXTURE_IMAGE_UNITS",
+        0x93B1, "GL_COMPRESSED_RGBA_ASTC_5x4_KHR",
     },
     {
-     0x8DC6,
-     "GL_UNSIGNED_INT_VEC2",
+        0x93B2, "GL_COMPRESSED_RGBA_ASTC_5x5_KHR",
     },
     {
-     0x8905,
-     "GL_MAX_PROGRAM_TEXEL_OFFSET",
+        0x93B3, "GL_COMPRESSED_RGBA_ASTC_6x5_KHR",
     },
     {
-     0x8508,
-     "GL_DECR_WRAP",
+        0x93B4, "GL_COMPRESSED_RGBA_ASTC_6x6_KHR",
     },
     {
-     0x92AD,
-     "GL_HSL_HUE_KHR",
+        0x93B5, "GL_COMPRESSED_RGBA_ASTC_8x5_KHR",
     },
     {
-     0x92AE,
-     "GL_HSL_SATURATION_KHR",
+        0x93B6, "GL_COMPRESSED_RGBA_ASTC_8x6_KHR",
     },
     {
-     0x92AF,
-     "GL_HSL_COLOR_KHR",
+        0x93B7, "GL_COMPRESSED_RGBA_ASTC_8x8_KHR",
     },
     {
-     0x8BD4,
-     "GL_TEXTURE_DEPTH_QCOM",
+        0x8CD6, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",
     },
     {
-     0x8DC4,
-     "GL_SAMPLER_2D_ARRAY_SHADOW_NV",
+        0x93B9, "GL_COMPRESSED_RGBA_ASTC_10x6_KHR",
     },
     {
-     0x8507,
-     "GL_INCR_WRAP",
+        0x80E9, "GL_MAX_ELEMENTS_INDICES",
     },
     {
-     0x82FC,
-     "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR",
+        0x8CE5, "GL_COLOR_ATTACHMENT5_EXT",
     },
     {
-     0x8895,
-     "GL_ELEMENT_ARRAY_BUFFER_BINDING",
+        0x8C84, "GL_TRANSFORM_FEEDBACK_BUFFER_START",
     },
     {
-     0x8894,
-     "GL_ARRAY_BUFFER_BINDING",
+        0x8DC2, "GL_SAMPLER_BUFFER_EXT",
     },
     {
-     0x92A3,
-     "GL_INVERT_RGB_NV",
+        0x8C36, "GL_SAMPLE_SHADING_OES",
     },
     {
-     0x905F,
-     "GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT",
+        0x8C37, "GL_MIN_SAMPLE_SHADING_VALUE_OES",
     },
     {
-     0x92A5,
-     "GL_LINEARBURN_NV",
+        0x8F97, "GL_RGBA8_SNORM",
     },
     {
-     0x8893,
-     "GL_ELEMENT_ARRAY_BUFFER",
+        0x8CE9, "GL_COLOR_ATTACHMENT9_EXT",
     },
     {
-     0x8892,
-     "GL_ARRAY_BUFFER",
+        0x8DAD, "GL_FLOAT_32_UNSIGNED_INT_24_8_REV",
     },
     {
-     0x92A8,
-     "GL_PINLIGHT_NV",
+        0x8B96, "GL_PALETTE8_RGBA8_OES",
     },
     {
-     0x92A9,
-     "GL_HARDMIX_NV",
+        0x8872, "GL_MAX_TEXTURE_IMAGE_UNITS",
     },
     {
-     0x9112,
-     "GL_OBJECT_TYPE_APPLE",
+        0x0A, "GL_QUADRATIC_CURVE_TO_CHROMIUM",
     },
     {
-     0x90CC,
-     "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT",
+        0x8905, "GL_MAX_PROGRAM_TEXEL_OFFSET",
     },
     {
-     0x90CD,
-     "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT",
+        0x8508, "GL_DECR_WRAP",
     },
     {
-     0x919F,
-     "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT",
+        0x92AD, "GL_HSL_HUE_KHR",
     },
     {
-     0x919E,
-     "GL_TEXTURE_BUFFER_SIZE_EXT",
+        0x92AE, "GL_HSL_SATURATION_KHR",
     },
     {
-     0x919D,
-     "GL_TEXTURE_BUFFER_OFFSET_EXT",
+        0x92AF, "GL_HSL_COLOR_KHR",
     },
     {
-     0x8BD8,
-     "GL_TEXTURE_IMAGE_VALID_QCOM",
+        0x8BD4, "GL_TEXTURE_DEPTH_QCOM",
     },
     {
-     0x9278,
-     "GL_COMPRESSED_RGBA8_ETC2_EAC",
+        0x8DC4, "GL_SAMPLER_2D_ARRAY_SHADOW_NV",
     },
     {
-     0x9279,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC",
+        0x8507, "GL_INCR_WRAP",
     },
     {
-     0x8DA7,
-     "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT",
+        0x82FC, "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR",
     },
     {
-     0x9272,
-     "GL_COMPRESSED_RG11_EAC",
+        0x8895, "GL_ELEMENT_ARRAY_BUFFER_BINDING",
     },
     {
-     0x8DA8,
-     "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT",
+        0x8894, "GL_ARRAY_BUFFER_BINDING",
     },
     {
-     0x9270,
-     "GL_COMPRESSED_R11_EAC",
+        0x92A3, "GL_INVERT_RGB_NV",
     },
     {
-     0x9271,
-     "GL_COMPRESSED_SIGNED_R11_EAC",
+        0x905F, "GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT",
     },
     {
-     0x9276,
-     "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2",
+        0x92A5, "GL_LINEARBURN_NV",
     },
     {
-     0x887F,
-     "GL_GEOMETRY_SHADER_INVOCATIONS_EXT",
+        0x8893, "GL_ELEMENT_ARRAY_BUFFER",
     },
     {
-     0x8A3B,
-     "GL_UNIFORM_OFFSET",
+        0x8892, "GL_ARRAY_BUFFER",
     },
     {
-     0x9275,
-     "GL_COMPRESSED_SRGB8_ETC2",
+        0x92A8, "GL_PINLIGHT_NV",
     },
     {
-     0x84D5,
-     "GL_TEXTURE21",
+        0x92A9, "GL_HARDMIX_NV",
     },
     {
-     0x8C3A,
-     "GL_R11F_G11F_B10F_APPLE",
+        0x9112, "GL_OBJECT_TYPE_APPLE",
     },
     {
-     0x8C3B,
-     "GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE",
+        0x90CC, "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT",
     },
     {
-     0x8C3D,
-     "GL_RGB9_E5_APPLE",
+        0x90CD, "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT",
     },
     {
-     0x8C3E,
-     "GL_UNSIGNED_INT_5_9_9_9_REV_APPLE",
+        0x919F, "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT",
     },
     {
-     0x9287,
-     "GL_DST_NV",
+        0x919E, "GL_TEXTURE_BUFFER_SIZE_EXT",
     },
     {
-     0x93BA,
-     "GL_COMPRESSED_RGBA_ASTC_10x8_KHR",
+        0x919D, "GL_TEXTURE_BUFFER_OFFSET_EXT",
     },
     {
-     0x9285,
-     "GL_BLEND_ADVANCED_COHERENT_KHR",
+        0x8BD8, "GL_TEXTURE_IMAGE_VALID_QCOM",
     },
     {
-     0x93BC,
-     "GL_COMPRESSED_RGBA_ASTC_12x10_KHR",
+        0x9278, "GL_COMPRESSED_RGBA8_ETC2_EAC",
     },
     {
-     0x93BD,
-     "GL_COMPRESSED_RGBA_ASTC_12x12_KHR",
+        0x9279, "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC",
     },
     {
-     0x84E8,
-     "GL_MAX_RENDERBUFFER_SIZE",
+        0x8DA7, "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT",
     },
     {
-     0x9281,
-     "GL_BLEND_OVERLAP_NV",
+        0x9272, "GL_COMPRESSED_RG11_EAC",
     },
     {
-     0x9280,
-     "GL_BLEND_PREMULTIPLIED_SRC_NV",
+        0x8DA8, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT",
     },
     {
-     0x00002000,
-     "GL_DEPTH_BUFFER_BIT5_QCOM",
+        0x9270, "GL_COMPRESSED_R11_EAC",
     },
     {
-     0x8370,
-     "GL_MIRRORED_REPEAT",
+        0x9271, "GL_COMPRESSED_SIGNED_R11_EAC",
     },
     {
-     0x84E0,
-     "GL_ACTIVE_TEXTURE",
+        0x9276, "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2",
     },
     {
-     0x8800,
-     "GL_STENCIL_BACK_FUNC",
+        0x887F, "GL_GEOMETRY_SHADER_INVOCATIONS_EXT",
     },
     {
-     0x8801,
-     "GL_STENCIL_BACK_FAIL",
+        0x8A3B, "GL_UNIFORM_OFFSET",
     },
     {
-     0x0D33,
-     "GL_MAX_TEXTURE_SIZE",
+        0x9275, "GL_COMPRESSED_SRGB8_ETC2",
     },
     {
-     0x0D32,
-     "GL_MAX_CLIP_DISTANCES_APPLE",
+        0x8D7C, "GL_RGBA8UI",
     },
     {
-     0x8624,
-     "GL_VERTEX_ATTRIB_ARRAY_STRIDE",
+        0x84D5, "GL_TEXTURE21",
     },
     {
-     0x8625,
-     "GL_VERTEX_ATTRIB_ARRAY_TYPE",
+        0x8C3A, "GL_R11F_G11F_B10F_APPLE",
     },
     {
-     0x8622,
-     "GL_VERTEX_ATTRIB_ARRAY_ENABLED",
+        0x8C3B, "GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE",
     },
     {
-     0x8623,
-     "GL_VERTEX_ATTRIB_ARRAY_SIZE",
+        0x8C3D, "GL_RGB9_E5_APPLE",
     },
     {
-     0x8DB9,
-     "GL_FRAMEBUFFER_SRGB_EXT",
+        0x8C3E, "GL_UNSIGNED_INT_5_9_9_9_REV_APPLE",
     },
     {
-     0x9307,
-     "GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT",
+        0x9287, "GL_DST_NV",
     },
     {
-     0x8259,
-     "GL_ACTIVE_PROGRAM_EXT",
+        0x93BA, "GL_COMPRESSED_RGBA_ASTC_10x8_KHR",
     },
     {
-     0x8258,
-     "GL_PROGRAM_SEPARABLE_EXT",
+        0x9285, "GL_BLEND_ADVANCED_COHERENT_KHR",
     },
     {
-     0x8257,
-     "GL_PROGRAM_BINARY_RETRIEVABLE_HINT",
+        0x93BC, "GL_COMPRESSED_RGBA_ASTC_12x10_KHR",
     },
     {
-     0x8256,
-     "GL_RESET_NOTIFICATION_STRATEGY_KHR",
+        0x93BD, "GL_COMPRESSED_RGBA_ASTC_12x12_KHR",
     },
     {
-     0x8255,
-     "GL_UNKNOWN_CONTEXT_RESET_KHR",
+        0x84E8, "GL_MAX_RENDERBUFFER_SIZE",
     },
     {
-     0x8254,
-     "GL_INNOCENT_CONTEXT_RESET_KHR",
+        0x9281, "GL_BLEND_OVERLAP_NV",
     },
     {
-     0x1100,
-     "GL_DONT_CARE",
+        0x9280, "GL_BLEND_PREMULTIPLIED_SRC_NV",
     },
     {
-     0x1101,
-     "GL_FASTEST",
+        0x00002000, "GL_DEPTH_BUFFER_BIT5_QCOM",
     },
     {
-     0x1102,
-     "GL_NICEST",
+        0x8370, "GL_MIRRORED_REPEAT",
     },
     {
-     0x8250,
-     "GL_DEBUG_TYPE_PERFORMANCE_KHR",
+        0x84E0, "GL_ACTIVE_TEXTURE",
     },
     {
-     0x8CEB,
-     "GL_COLOR_ATTACHMENT11_EXT",
+        0x8800, "GL_STENCIL_BACK_FUNC",
     },
     {
-     0x8CEC,
-     "GL_COLOR_ATTACHMENT12_EXT",
+        0x8801, "GL_STENCIL_BACK_FAIL",
     },
     {
-     0x0408,
-     "GL_FRONT_AND_BACK",
+        0x0D33, "GL_MAX_TEXTURE_SIZE",
     },
     {
-     0x8CEA,
-     "GL_COLOR_ATTACHMENT10_EXT",
+        0x0D32, "GL_MAX_CLIP_DISTANCES_APPLE",
     },
     {
-     0x8CEF,
-     "GL_COLOR_ATTACHMENT15_EXT",
+        0x8624, "GL_VERTEX_ATTRIB_ARRAY_STRIDE",
     },
     {
-     0x8CED,
-     "GL_COLOR_ATTACHMENT13_EXT",
+        0x8625, "GL_VERTEX_ATTRIB_ARRAY_TYPE",
     },
     {
-     0x8829,
-     "GL_DRAW_BUFFER4_EXT",
+        0x8622, "GL_VERTEX_ATTRIB_ARRAY_ENABLED",
     },
     {
-     0x0404,
-     "GL_FRONT",
+        0x8623, "GL_VERTEX_ATTRIB_ARRAY_SIZE",
     },
     {
-     0x0405,
-     "GL_BACK",
+        0x8DB9, "GL_FRAMEBUFFER_SRGB_EXT",
     },
     {
-     0x88E1,
-     "GL_STREAM_READ",
+        0x9307, "GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT",
     },
     {
-     0x88E0,
-     "GL_STREAM_DRAW",
+        0x8259, "GL_ACTIVE_PROGRAM_EXT",
     },
     {
-     0x88E2,
-     "GL_STREAM_COPY",
+        0x8258, "GL_PROGRAM_SEPARABLE_EXT",
     },
     {
-     0x88E5,
-     "GL_STATIC_READ",
+        0x8257, "GL_PROGRAM_BINARY_RETRIEVABLE_HINT",
     },
     {
-     0x88E4,
-     "GL_STATIC_DRAW",
+        0x8256, "GL_RESET_NOTIFICATION_STRATEGY_KHR",
     },
     {
-     0x93C6,
-     "GL_COMPRESSED_RGBA_ASTC_5x5x5_OES",
+        0x8255, "GL_UNKNOWN_CONTEXT_RESET_KHR",
     },
     {
-     0x88E9,
-     "GL_DYNAMIC_READ",
+        0x8254, "GL_INNOCENT_CONTEXT_RESET_KHR",
     },
     {
-     0x88E8,
-     "GL_DYNAMIC_DRAW",
+        0x1100, "GL_DONT_CARE",
     },
     {
-     0x9291,
-     "GL_PLUS_NV",
+        0x1101, "GL_FASTEST",
     },
     {
-     0x8CAA,
-     "GL_READ_FRAMEBUFFER_BINDING_ANGLE",
+        0x1102, "GL_NICEST",
     },
     {
-     0x93C5,
-     "GL_COMPRESSED_RGBA_ASTC_5x5x4_OES",
+        0x8250, "GL_DEBUG_TYPE_PERFORMANCE_KHR",
     },
     {
-     0x40000000,
-     "GL_MULTISAMPLE_BUFFER_BIT6_QCOM",
+        0x8CEB, "GL_COLOR_ATTACHMENT11_EXT",
     },
     {
-     0x88EA,
-     "GL_DYNAMIC_COPY",
+        0x8CEC, "GL_COLOR_ATTACHMENT12_EXT",
     },
     {
-     0x9116,
-     "GL_SYNC_FENCE_APPLE",
+        0x0408, "GL_FRONT_AND_BACK",
     },
     {
-     0x93C4,
-     "GL_COMPRESSED_RGBA_ASTC_5x4x4_OES",
+        0x8CEA, "GL_COLOR_ATTACHMENT10_EXT",
     },
     {
-     0x88EE,
-     "GL_ETC1_SRGB8_NV",
+        0x8CEF, "GL_COLOR_ATTACHMENT15_EXT",
     },
     {
-     0x78EC,
-     "GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM",
+        0x8CED, "GL_COLOR_ATTACHMENT13_EXT",
     },
     {
-     0x88EF,
-     "GL_PIXEL_UNPACK_BUFFER_BINDING",
+        0x8829, "GL_DRAW_BUFFER4_EXT",
     },
     {
-     0x93C3,
-     "GL_COMPRESSED_RGBA_ASTC_4x4x4_OES",
+        0x0404, "GL_FRONT",
     },
     {
-     0x00000800,
-     "GL_DEPTH_BUFFER_BIT3_QCOM",
+        0x0405, "GL_BACK",
     },
     {
-     0x1903,
-     "GL_RED_EXT",
+        0x88E1, "GL_STREAM_READ",
     },
     {
-     0x93C2,
-     "GL_COMPRESSED_RGBA_ASTC_4x4x3_OES",
+        0x88E0, "GL_STREAM_DRAW",
     },
     {
-     0x8CE2,
-     "GL_COLOR_ATTACHMENT2_EXT",
+        0x88E2, "GL_STREAM_COPY",
     },
     {
-     0x8BC1,
-     "GL_COUNTER_RANGE_AMD",
+        0x88E5, "GL_STATIC_READ",
     },
     {
-     0x8CE0,
-     "GL_COLOR_ATTACHMENT0",
+        0x88E4, "GL_STATIC_DRAW",
     },
     {
-     0x8CE1,
-     "GL_COLOR_ATTACHMENT1_EXT",
+        0x93C6, "GL_COMPRESSED_RGBA_ASTC_5x5x5_OES",
     },
     {
-     0x8CE6,
-     "GL_COLOR_ATTACHMENT6_EXT",
+        0x88E9, "GL_DYNAMIC_READ",
     },
     {
-     0x93C1,
-     "GL_COMPRESSED_RGBA_ASTC_4x3x3_OES",
+        0x88E8, "GL_DYNAMIC_DRAW",
     },
     {
-     0x8A1F,
-     "GL_RGB_422_APPLE",
+        0x9291, "GL_PLUS_NV",
     },
     {
-     0x93DC,
-     "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR",
+        0x8CAA, "GL_READ_FRAMEBUFFER_BINDING_ANGLE",
     },
     {
-     0x9292,
-     "GL_PLUS_DARKER_NV",
+        0x93C5, "GL_COMPRESSED_RGBA_ASTC_5x5x4_OES",
     },
     {
-     0x8CE8,
-     "GL_COLOR_ATTACHMENT8_EXT",
+        0x40000000, "GL_MULTISAMPLE_BUFFER_BIT6_QCOM",
     },
     {
-     0x93C0,
-     "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES",
+        0x88EA, "GL_DYNAMIC_COPY",
     },
     {
-     0x0C23,
-     "GL_COLOR_WRITEMASK",
+        0x9116, "GL_SYNC_FENCE_APPLE",
     },
     {
-     0x0C22,
-     "GL_COLOR_CLEAR_VALUE",
+        0x93C4, "GL_COMPRESSED_RGBA_ASTC_5x4x4_OES",
     },
     {
-     0x8A11,
-     "GL_UNIFORM_BUFFER",
+        0x88EE, "GL_ETC1_SRGB8_NV",
     },
     {
-     0x8823,
-     "GL_WRITEONLY_RENDERING_QCOM",
+        0x78EC, "GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM",
     },
     {
-     0x8824,
-     "GL_MAX_DRAW_BUFFERS_EXT",
+        0x88EF, "GL_PIXEL_UNPACK_BUFFER_BINDING",
     },
     {
-     0x825E,
-     "GL_LAYER_PROVOKING_VERTEX_EXT",
+        0x93C3, "GL_COMPRESSED_RGBA_ASTC_4x4x4_OES",
     },
     {
-     0x825A,
-     "GL_PROGRAM_PIPELINE_BINDING_EXT",
+        0x00000800, "GL_DEPTH_BUFFER_BIT3_QCOM",
     },
     {
-     0x1909,
-     "GL_LUMINANCE",
+        0x1903, "GL_RED_EXT",
     },
     {
-     0x0D3A,
-     "GL_MAX_VIEWPORT_DIMS",
+        0x93C2, "GL_COMPRESSED_RGBA_ASTC_4x4x3_OES",
     },
     {
-     0x8B53,
-     "GL_INT_VEC2",
+        0x8CE2, "GL_COLOR_ATTACHMENT2_EXT",
     },
     {
-     0x8826,
-     "GL_DRAW_BUFFER1_EXT",
+        0x8BC1, "GL_COUNTER_RANGE_AMD",
     },
     {
-     0x809E,
-     "GL_SAMPLE_ALPHA_TO_COVERAGE",
+        0x8CE0, "GL_COLOR_ATTACHMENT0",
     },
     {
-     0x8BC0,
-     "GL_COUNTER_TYPE_AMD",
+        0x8CE1, "GL_COLOR_ATTACHMENT1_EXT",
     },
     {
-     0x8BC3,
-     "GL_PERCENTAGE_AMD",
+        0x8CE6, "GL_COLOR_ATTACHMENT6_EXT",
     },
     {
-     0x8BC2,
-     "GL_UNSIGNED_INT64_AMD",
+        0x93C1, "GL_COMPRESSED_RGBA_ASTC_4x3x3_OES",
     },
     {
-     0x8BC5,
-     "GL_PERFMON_RESULT_SIZE_AMD",
+        0x8A1F, "GL_RGB_422_APPLE",
     },
     {
-     0x8BC4,
-     "GL_PERFMON_RESULT_AVAILABLE_AMD",
+        0x93DC, "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR",
     },
     {
-     0x8BC6,
-     "GL_PERFMON_RESULT_AMD",
+        0x9292, "GL_PLUS_DARKER_NV",
+    },
+    {
+        0x8CE8, "GL_COLOR_ATTACHMENT8_EXT",
+    },
+    {
+        0x93C0, "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES",
+    },
+    {
+        0x0C23, "GL_COLOR_WRITEMASK",
+    },
+    {
+        0x0C22, "GL_COLOR_CLEAR_VALUE",
+    },
+    {
+        0x8A11, "GL_UNIFORM_BUFFER",
+    },
+    {
+        0x8823, "GL_WRITEONLY_RENDERING_QCOM",
+    },
+    {
+        0x8824, "GL_MAX_DRAW_BUFFERS_EXT",
+    },
+    {
+        0x825E, "GL_LAYER_PROVOKING_VERTEX_EXT",
+    },
+    {
+        0x825A, "GL_PROGRAM_PIPELINE_BINDING_EXT",
+    },
+    {
+        0x1909, "GL_LUMINANCE",
+    },
+    {
+        0x0D3A, "GL_MAX_VIEWPORT_DIMS",
+    },
+    {
+        0x8B53, "GL_INT_VEC2",
+    },
+    {
+        0x8826, "GL_DRAW_BUFFER1_EXT",
+    },
+    {
+        0x809E, "GL_SAMPLE_ALPHA_TO_COVERAGE",
+    },
+    {
+        0x8BC0, "GL_COUNTER_TYPE_AMD",
+    },
+    {
+        0x8BC3, "GL_PERCENTAGE_AMD",
+    },
+    {
+        0x8BC2, "GL_UNSIGNED_INT64_AMD",
+    },
+    {
+        0x8BC5, "GL_PERFMON_RESULT_SIZE_AMD",
+    },
+    {
+        0x8BC4, "GL_PERFMON_RESULT_AVAILABLE_AMD",
+    },
+    {
+        0x8BC6, "GL_PERFMON_RESULT_AMD",
     },
 };
 
diff --git a/chromium/ui/gl/gl_gl_api_implementation.cc b/chromium/ui/gl/gl_gl_api_implementation.cc
index 57b0333854c..9ebb3aec94e 100644
--- a/chromium/ui/gl/gl_gl_api_implementation.cc
+++ b/chromium/ui/gl/gl_gl_api_implementation.cc
@@ -50,7 +50,8 @@ static inline GLenum GetTexInternalFormat(GLenum internal_format,
   // g_version_info must be initialized when this function is bound.
   DCHECK(gfx::g_version_info);
   if (gfx::g_version_info->is_es3) {
-    if (format == GL_RED_EXT) {
+    if (internal_format == GL_RED_EXT) {
+      // GL_EXT_texture_rg case in ES2.
       switch (type) {
         case GL_UNSIGNED_BYTE:
           gl_internal_format = GL_R8_EXT;
@@ -66,7 +67,8 @@ static inline GLenum GetTexInternalFormat(GLenum internal_format,
           break;
       }
       return gl_internal_format;
-    } else if (format == GL_RG_EXT) {
+    } else if (internal_format == GL_RG_EXT) {
+      // GL_EXT_texture_rg case in ES2.
       switch (type) {
         case GL_UNSIGNED_BYTE:
           gl_internal_format = GL_RG8_EXT;
@@ -108,7 +110,8 @@ static inline GLenum GetTexInternalFormat(GLenum internal_format,
     return gl_internal_format;
 
   if (type == GL_FLOAT) {
-    switch (format) {
+    switch (internal_format) {
+      // We need to map all the unsized internal formats from ES2 clients.
       case GL_RGBA:
         gl_internal_format = GL_RGBA32F_ARB;
         break;
@@ -125,11 +128,12 @@ static inline GLenum GetTexInternalFormat(GLenum internal_format,
         gl_internal_format = GL_ALPHA32F_ARB;
         break;
       default:
-        NOTREACHED();
+        // We can't assert here because if the client context is ES3,
+        // all sized internal_format will reach here.
         break;
     }
   } else if (type == GL_HALF_FLOAT_OES) {
-    switch (format) {
+    switch (internal_format) {
       case GL_RGBA:
         gl_internal_format = GL_RGBA16F_ARB;
         break;
@@ -471,13 +475,13 @@ void RealGLApi::glFinishFn() {
 void RealGLApi::InitializeFilteredExtensions() {
   if (disabled_exts_.size()) {
     filtered_exts_.clear();
-    if (gfx::GetGLImplementation() !=
-        gfx::kGLImplementationDesktopGLCoreProfile) {
+    if (gfx::WillUseGLGetStringForExtensions()) {
       filtered_exts_str_ =
           FilterGLExtensionList(reinterpret_cast<const char*>(
                                     GLApiBase::glGetStringFn(GL_EXTENSIONS)),
                                 disabled_exts_);
-      base::SplitString(filtered_exts_str_, ' ', &filtered_exts_);
+      filtered_exts_ = base::SplitString(
+          filtered_exts_str_, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     } else {
       GLint num_extensions = 0;
       GLApiBase::glGetIntegervFn(GL_NUM_EXTENSIONS, &num_extensions);
@@ -490,7 +494,7 @@ void RealGLApi::InitializeFilteredExtensions() {
           filtered_exts_.push_back(gl_extension);
         }
       }
-      filtered_exts_str_ = JoinString(filtered_exts_, " ");
+      filtered_exts_str_ = base::JoinString(filtered_exts_, " ");
     }
 #if DCHECK_IS_ON()
     filtered_exts_initialized_ = true;
@@ -520,19 +524,7 @@ void VirtualGLApi::Initialize(DriverGL* driver, GLContext* real_context) {
   real_context_ = real_context;
 
   DCHECK(real_context->IsCurrent(NULL));
-  std::string ext_string = real_context->GetExtensions();
-  std::vector<std::string> ext = base::SplitString(
-      ext_string, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-
-  std::vector<std::string>::iterator it;
-  // We can't support GL_EXT_occlusion_query_boolean which is
-  // based on GL_ARB_occlusion_query without a lot of work virtualizing
-  // queries.
-  it = std::find(ext.begin(), ext.end(), "GL_EXT_occlusion_query_boolean");
-  if (it != ext.end())
-    ext.erase(it);
-
-  extensions_ = JoinString(ext, " ");
+  extensions_ = real_context->GetExtensions();
 }
 
 bool VirtualGLApi::MakeCurrent(GLContext* virtual_context, GLSurface* surface) {
@@ -565,16 +557,27 @@ bool VirtualGLApi::MakeCurrent(GLContext* virtual_context, GLSurface* surface) {
     // context loss handling in virtual context mode.
     // There should be no other errors from the previous context leaking into
     // the new context.
-    DCHECK(error == GL_NO_ERROR || error == GL_CONTEXT_LOST_KHR);
+    DCHECK(error == GL_NO_ERROR || error == GL_CONTEXT_LOST_KHR) <<
+        "GL error was: " << error;
 #endif
 
     // Set all state that is different from the real state
     GLApi* temp = GetCurrentGLApi();
     SetGLToRealGLApi();
     if (virtual_context->GetGLStateRestorer()->IsInitialized()) {
-      virtual_context->GetGLStateRestorer()->RestoreState(
-          (current_context_ && !state_dirtied_externally && !switched_contexts)
-              ? current_context_->GetGLStateRestorer()
+      GLStateRestorer* virtual_state = virtual_context->GetGLStateRestorer();
+      GLStateRestorer* current_state = current_context_ ?
+                                       current_context_->GetGLStateRestorer() :
+                                       nullptr;
+      if (switched_contexts || virtual_context != current_context_) {
+        if (current_state)
+          current_state->PauseQueries();
+        virtual_state->ResumeQueries();
+      }
+
+      virtual_state->RestoreState(
+          (current_state && !state_dirtied_externally && !switched_contexts)
+              ? current_state
               : NULL);
     }
     SetGLApi(temp);
@@ -612,13 +615,4 @@ void VirtualGLApi::glFinishFn() {
   GLApiBase::glFinishFn();
 }
 
-ScopedSetGLToRealGLApi::ScopedSetGLToRealGLApi()
-    : old_gl_api_(GetCurrentGLApi()) {
-  SetGLToRealGLApi();
-}
-
-ScopedSetGLToRealGLApi::~ScopedSetGLToRealGLApi() {
-  SetGLApi(old_gl_api_);
-}
-
 }  // namespace gfx
diff --git a/chromium/ui/gl/gl_gl_api_implementation.h b/chromium/ui/gl/gl_gl_api_implementation.h
index a5197fed774..cfefb1384bc 100644
--- a/chromium/ui/gl/gl_gl_api_implementation.h
+++ b/chromium/ui/gl/gl_gl_api_implementation.h
@@ -36,6 +36,7 @@ void ClearGLBindingsGL();
 void SetGLToRealGLApi();
 void SetGLApi(GLApi* api);
 void SetGLApiToNoContext();
+GLApi* GetCurrentGLApi();
 const GLVersionInfo* GetGLVersionInfo();
 
 class GL_EXPORT GLApiBase : public GLApi {
@@ -139,15 +140,6 @@ private:
   std::string extensions_;
 };
 
-class GL_EXPORT ScopedSetGLToRealGLApi {
- public:
-  ScopedSetGLToRealGLApi();
-  ~ScopedSetGLToRealGLApi();
-
- private:
-  GLApi* old_gl_api_;
-};
-
 }  // namespace gfx
 
 #endif  // UI_GL_GL_GL_API_IMPLEMENTATION_H_
diff --git a/chromium/ui/gl/gl_image.h b/chromium/ui/gl/gl_image.h
index b48b687957c..a23669952a8 100644
--- a/chromium/ui/gl/gl_image.h
+++ b/chromium/ui/gl/gl_image.h
@@ -14,6 +14,12 @@
 #include "ui/gfx/overlay_transform.h"
 #include "ui/gl/gl_export.h"
 
+namespace base {
+namespace trace_event {
+class ProcessMemoryDump;
+}
+}
+
 namespace gfx {
 
 // Encapsulates an image that can be bound to a texture, hiding platform
@@ -61,6 +67,12 @@ class GL_EXPORT GLImage : public base::RefCounted<GLImage> {
                                     const Rect& bounds_rect,
                                     const RectF& crop_rect) = 0;
 
+  // Dumps information about the memory backing the GLImage to a dump named
+  // |dump_name|.
+  virtual void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                            uint64_t process_tracing_id,
+                            const std::string& dump_name) = 0;
+
  protected:
   virtual ~GLImage() {}
 
diff --git a/chromium/ui/gl/gl_image_glx.cc b/chromium/ui/gl/gl_image_glx.cc
index f22ba0ff622..496cf449bb8 100644
--- a/chromium/ui/gl/gl_image_glx.cc
+++ b/chromium/ui/gl/gl_image_glx.cc
@@ -203,4 +203,10 @@ bool GLImageGLX::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
   return false;
 }
 
+void GLImageGLX::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                              uint64_t process_tracing_id,
+                              const std::string& dump_name) {
+  // TODO(ericrk): Implement GLImage OnMemoryDump. crbug.com/514914
+}
+
 }  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_glx.h b/chromium/ui/gl/gl_image_glx.h
index a8689708826..5de1d0d165f 100644
--- a/chromium/ui/gl/gl_image_glx.h
+++ b/chromium/ui/gl/gl_image_glx.h
@@ -36,6 +36,9 @@ class GL_EXPORT GLImageGLX : public GLImage {
                             OverlayTransform transform,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
 
  protected:
   ~GLImageGLX() override;
diff --git a/chromium/ui/gl/gl_image_io_surface.cc b/chromium/ui/gl/gl_image_io_surface.cc
deleted file mode 100644
index adcadee363a..00000000000
--- a/chromium/ui/gl/gl_image_io_surface.cc
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright 2013 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_image_io_surface.h"
-
-#include "ui/gl/gl_bindings.h"
-#include "ui/gl/gl_context.h"
-
-// Note that this must be included after gl_bindings.h to avoid conflicts.
-#include <OpenGL/CGLIOSurface.h>
-
-namespace gfx {
-namespace {
-
-bool ValidInternalFormat(unsigned internalformat) {
-  switch (internalformat) {
-    case GL_R8:
-    case GL_BGRA_EXT:
-      return true;
-    default:
-      return false;
-  }
-}
-
-bool ValidFormat(GpuMemoryBuffer::Format format) {
-  switch (format) {
-    case GpuMemoryBuffer::R_8:
-    case GpuMemoryBuffer::BGRA_8888:
-      return true;
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::RGBX_8888:
-    case GpuMemoryBuffer::YUV_420:
-      return false;
-  }
-
-  NOTREACHED();
-  return false;
-}
-
-GLenum TextureFormat(GpuMemoryBuffer::Format format) {
-  switch (format) {
-    case GpuMemoryBuffer::R_8:
-      return GL_RED;
-    case GpuMemoryBuffer::BGRA_8888:
-      return GL_RGBA;
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::RGBX_8888:
-    case GpuMemoryBuffer::YUV_420:
-      NOTREACHED();
-      return 0;
-  }
-
-  NOTREACHED();
-  return 0;
-}
-
-GLenum DataFormat(GpuMemoryBuffer::Format format) {
-  switch (format) {
-    case GpuMemoryBuffer::R_8:
-      return GL_RED;
-    case GpuMemoryBuffer::BGRA_8888:
-      return GL_BGRA;
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::RGBX_8888:
-    case GpuMemoryBuffer::YUV_420:
-      NOTREACHED();
-      return 0;
-  }
-
-  NOTREACHED();
-  return 0;
-}
-
-GLenum DataType(GpuMemoryBuffer::Format format) {
-  switch (format) {
-    case GpuMemoryBuffer::R_8:
-      return GL_UNSIGNED_BYTE;
-    case GpuMemoryBuffer::BGRA_8888:
-      return GL_UNSIGNED_INT_8_8_8_8_REV;
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::RGBX_8888:
-    case GpuMemoryBuffer::YUV_420:
-      NOTREACHED();
-      return 0;
-  }
-
-  NOTREACHED();
-  return 0;
-}
-
-}  // namespace
-
-GLImageIOSurface::GLImageIOSurface(const gfx::Size& size,
-                                   unsigned internalformat)
-    : size_(size),
-      internalformat_(internalformat),
-      format_(GpuMemoryBuffer::RGBA_8888) {
-}
-
-GLImageIOSurface::~GLImageIOSurface() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!io_surface_);
-}
-
-bool GLImageIOSurface::Initialize(IOSurfaceRef io_surface,
-                                  GpuMemoryBuffer::Format format) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!io_surface_);
-
-  if (!ValidInternalFormat(internalformat_)) {
-    LOG(ERROR) << "Invalid internalformat: " << internalformat_;
-    return false;
-  }
-
-  if (!ValidFormat(format)) {
-    LOG(ERROR) << "Invalid format: " << format;
-    return false;
-  }
-
-  format_ = format;
-  io_surface_.reset(io_surface, base::scoped_policy::RETAIN);
-  return true;
-}
-
-void GLImageIOSurface::Destroy(bool have_context) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  io_surface_.reset();
-}
-
-gfx::Size GLImageIOSurface::GetSize() { return size_; }
-
-unsigned GLImageIOSurface::GetInternalFormat() { return internalformat_; }
-
-bool GLImageIOSurface::BindTexImage(unsigned target) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (target != GL_TEXTURE_RECTANGLE_ARB) {
-    // This might be supported in the future. For now, perform strict
-    // validation so we know what's going on.
-    LOG(ERROR) << "IOSurface requires TEXTURE_RECTANGLE_ARB target";
-    return false;
-  }
-
-  CGLContextObj cgl_context =
-      static_cast<CGLContextObj>(GLContext::GetCurrent()->GetHandle());
-
-  DCHECK(io_surface_);
-  CGLError cgl_error =
-      CGLTexImageIOSurface2D(cgl_context, target, TextureFormat(format_),
-                             size_.width(), size_.height(), DataFormat(format_),
-                             DataType(format_), io_surface_.get(), 0);
-  if (cgl_error != kCGLNoError) {
-    LOG(ERROR) << "Error in CGLTexImageIOSurface2D";
-    return false;
-  }
-
-  return true;
-}
-
-bool GLImageIOSurface::CopyTexSubImage(unsigned target,
-                                       const Point& offset,
-                                       const Rect& rect) {
-  return false;
-}
-
-bool GLImageIOSurface::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                                            int z_order,
-                                            OverlayTransform transform,
-                                            const Rect& bounds_rect,
-                                            const RectF& crop_rect) {
-  return false;
-}
-
-}  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_io_surface.h b/chromium/ui/gl/gl_image_io_surface.h
index 85606ffcd0a..bf65b0f56df 100644
--- a/chromium/ui/gl/gl_image_io_surface.h
+++ b/chromium/ui/gl/gl_image_io_surface.h
@@ -5,20 +5,28 @@
 #ifndef UI_GL_GL_IMAGE_IO_SURFACE_H_
 #define UI_GL_GL_IMAGE_IO_SURFACE_H_
 
-#include <IOSurface/IOSurfaceAPI.h>
+#include <IOSurface/IOSurface.h>
 
 #include "base/mac/scoped_cftyperef.h"
 #include "base/threading/thread_checker.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gl_image.h"
 
+#if defined(__OBJC__)
+@class CALayer;
+#else
+typedef void* CALayer;
+#endif
+
 namespace gfx {
 
 class GL_EXPORT GLImageIOSurface : public GLImage {
  public:
-  GLImageIOSurface(const gfx::Size& size, unsigned internalformat);
+  GLImageIOSurface(gfx::GenericSharedMemoryId io_surface_id,
+                   const gfx::Size& size,
+                   unsigned internalformat);
 
-  bool Initialize(IOSurfaceRef io_surface, GpuMemoryBuffer::Format format);
+  bool Initialize(IOSurfaceRef io_surface, BufferFormat format);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
@@ -38,14 +46,23 @@ class GL_EXPORT GLImageIOSurface : public GLImage {
                             OverlayTransform transform,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
+
+  base::ScopedCFTypeRef<IOSurfaceRef> io_surface();
+
+  static void SetLayerForWidget(gfx::AcceleratedWidget widget,
+                                CALayer* layer);
 
  protected:
   ~GLImageIOSurface() override;
 
  private:
+  gfx::GenericSharedMemoryId io_surface_id_;
   const gfx::Size size_;
   const unsigned internalformat_;
-  GpuMemoryBuffer::Format format_;
+  BufferFormat format_;
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface_;
   base::ThreadChecker thread_checker_;
 
diff --git a/chromium/ui/gl/gl_image_io_surface.mm b/chromium/ui/gl/gl_image_io_surface.mm
new file mode 100644
index 00000000000..211226a27b3
--- /dev/null
+++ b/chromium/ui/gl/gl_image_io_surface.mm
@@ -0,0 +1,255 @@
+// Copyright 2013 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_image_io_surface.h"
+
+#include <map>
+
+#include "base/lazy_instance.h"
+#include "base/mac/foundation_util.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_context.h"
+
+// Note that this must be included after gl_bindings.h to avoid conflicts.
+#include <OpenGL/CGLIOSurface.h>
+#include <Quartz/Quartz.h>
+
+namespace gfx {
+namespace {
+
+typedef std::map<gfx::AcceleratedWidget,CALayer*> WidgetToLayerMap;
+base::LazyInstance<WidgetToLayerMap> g_widget_to_layer_map;
+
+bool ValidInternalFormat(unsigned internalformat) {
+  switch (internalformat) {
+    case GL_R8:
+    case GL_BGRA_EXT:
+    case GL_RGB:
+    case GL_RGB_YCBCR_422_CHROMIUM:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool ValidFormat(BufferFormat format) {
+  switch (format) {
+    case BufferFormat::R_8:
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::UYVY_422:
+    case BufferFormat::YUV_420_BIPLANAR:
+      return true;
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+      return false;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
+GLenum TextureFormat(BufferFormat format) {
+  switch (format) {
+    case BufferFormat::R_8:
+    case BufferFormat::YUV_420_BIPLANAR:
+      return GL_RED;
+    case BufferFormat::BGRA_8888:
+      return GL_RGBA;
+    case BufferFormat::UYVY_422:
+      return GL_RGB;
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+      NOTREACHED();
+      return 0;
+  }
+
+  NOTREACHED();
+  return 0;
+}
+
+GLenum DataFormat(BufferFormat format) {
+  switch (format) {
+    case BufferFormat::R_8:
+    case BufferFormat::YUV_420_BIPLANAR:
+      return GL_RED;
+    case BufferFormat::BGRA_8888:
+      return GL_BGRA;
+    case BufferFormat::UYVY_422:
+      return GL_YCBCR_422_APPLE;
+      break;
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+      NOTREACHED();
+      return 0;
+  }
+
+  NOTREACHED();
+  return 0;
+}
+
+GLenum DataType(BufferFormat format) {
+  switch (format) {
+    case BufferFormat::R_8:
+    case BufferFormat::YUV_420_BIPLANAR:
+      return GL_UNSIGNED_BYTE;
+    case BufferFormat::BGRA_8888:
+      return GL_UNSIGNED_INT_8_8_8_8_REV;
+    case BufferFormat::UYVY_422:
+      return GL_UNSIGNED_SHORT_8_8_APPLE;
+      break;
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+      NOTREACHED();
+      return 0;
+  }
+
+  NOTREACHED();
+  return 0;
+}
+
+}  // namespace
+
+GLImageIOSurface::GLImageIOSurface(gfx::GenericSharedMemoryId io_surface_id,
+                                   const gfx::Size& size,
+                                   unsigned internalformat)
+    : io_surface_id_(io_surface_id),
+      size_(size),
+      internalformat_(internalformat),
+      format_(BufferFormat::RGBA_8888) {}
+
+GLImageIOSurface::~GLImageIOSurface() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!io_surface_);
+}
+
+bool GLImageIOSurface::Initialize(IOSurfaceRef io_surface,
+                                  BufferFormat format) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!io_surface_);
+
+  if (!ValidInternalFormat(internalformat_)) {
+    LOG(ERROR) << "Invalid internalformat: " << internalformat_;
+    return false;
+  }
+
+  if (!ValidFormat(format)) {
+    LOG(ERROR) << "Invalid format: " << static_cast<int>(format);
+    return false;
+  }
+
+  format_ = format;
+  io_surface_.reset(io_surface, base::scoped_policy::RETAIN);
+  return true;
+}
+
+void GLImageIOSurface::Destroy(bool have_context) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  io_surface_.reset();
+}
+
+gfx::Size GLImageIOSurface::GetSize() { return size_; }
+
+unsigned GLImageIOSurface::GetInternalFormat() { return internalformat_; }
+
+bool GLImageIOSurface::BindTexImage(unsigned target) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (target != GL_TEXTURE_RECTANGLE_ARB) {
+    // This might be supported in the future. For now, perform strict
+    // validation so we know what's going on.
+    LOG(ERROR) << "IOSurface requires TEXTURE_RECTANGLE_ARB target";
+    return false;
+  }
+
+  CGLContextObj cgl_context =
+      static_cast<CGLContextObj>(GLContext::GetCurrent()->GetHandle());
+
+  DCHECK(io_surface_);
+  CGLError cgl_error =
+      CGLTexImageIOSurface2D(cgl_context, target, TextureFormat(format_),
+                             size_.width(), size_.height(), DataFormat(format_),
+                             DataType(format_), io_surface_.get(), 0);
+  if (cgl_error != kCGLNoError) {
+    LOG(ERROR) << "Error in CGLTexImageIOSurface2D";
+    return false;
+  }
+
+  return true;
+}
+
+bool GLImageIOSurface::CopyTexSubImage(unsigned target,
+                                       const Point& offset,
+                                       const Rect& rect) {
+  return false;
+}
+
+bool GLImageIOSurface::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                                            int z_order,
+                                            OverlayTransform transform,
+                                            const Rect& bounds_rect,
+                                            const RectF& crop_rect) {
+  NOTREACHED();
+  return false;
+}
+
+void GLImageIOSurface::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                                    uint64_t process_tracing_id,
+                                    const std::string& dump_name) {
+  // IOSurfaceGetAllocSize will return 0 if io_surface_ is invalid. In this case
+  // we log 0 for consistency with other GLImage memory dump functions.
+  size_t size_bytes = IOSurfaceGetAllocSize(io_surface_);
+
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump(dump_name);
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  static_cast<uint64_t>(size_bytes));
+
+  auto guid = gfx::GetGenericSharedMemoryGUIDForTracing(process_tracing_id,
+                                                        io_surface_id_);
+  pmd->CreateSharedGlobalAllocatorDump(guid);
+  pmd->AddOwnershipEdge(dump->guid(), guid);
+}
+
+base::ScopedCFTypeRef<IOSurfaceRef> GLImageIOSurface::io_surface() {
+  return io_surface_;
+}
+
+// static
+void GLImageIOSurface::SetLayerForWidget(
+    gfx::AcceleratedWidget widget, CALayer* layer) {
+  if (layer)
+    g_widget_to_layer_map.Pointer()->insert(std::make_pair(widget, layer));
+  else
+    g_widget_to_layer_map.Pointer()->erase(widget);
+}
+
+}  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_linux_dma_buffer.cc b/chromium/ui/gl/gl_image_linux_dma_buffer.cc
deleted file mode 100644
index 30a76a6d714..00000000000
--- a/chromium/ui/gl/gl_image_linux_dma_buffer.cc
+++ /dev/null
@@ -1,126 +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_image_linux_dma_buffer.h"
-
-#include <unistd.h>
-
-#define FOURCC(a, b, c, d)                                    \
-  ((static_cast<uint32>(a)) | (static_cast<uint32>(b) << 8) | \
-   (static_cast<uint32>(c) << 16) | (static_cast<uint32>(d) << 24))
-
-#define DRM_FORMAT_ARGB8888 FOURCC('A', 'R', '2', '4')
-#define DRM_FORMAT_XRGB8888 FOURCC('X', 'R', '2', '4')
-
-namespace gfx {
-namespace {
-
-bool ValidInternalFormat(unsigned internalformat) {
-  switch (internalformat) {
-    case GL_RGB:
-    case GL_BGRA_EXT:
-      return true;
-    default:
-      return false;
-  }
-}
-
-bool ValidFormat(gfx::GpuMemoryBuffer::Format format) {
-  switch (format) {
-    case GpuMemoryBuffer::BGRA_8888:
-    case GpuMemoryBuffer::RGBX_8888:
-      return true;
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::R_8:
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::YUV_420:
-      return false;
-  }
-
-  NOTREACHED();
-  return false;
-}
-
-EGLint FourCC(gfx::GpuMemoryBuffer::Format format) {
-  switch (format) {
-    case GpuMemoryBuffer::BGRA_8888:
-      return DRM_FORMAT_ARGB8888;
-    case GpuMemoryBuffer::RGBX_8888:
-      return DRM_FORMAT_XRGB8888;
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::R_8:
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::YUV_420:
-      NOTREACHED();
-      return 0;
-  }
-
-  NOTREACHED();
-  return 0;
-}
-
-bool IsHandleValid(const base::FileDescriptor& handle) {
-  return handle.fd >= 0;
-}
-
-}  // namespace
-
-GLImageLinuxDMABuffer::GLImageLinuxDMABuffer(const Size& size,
-                                             unsigned internalformat)
-    : GLImageEGL(size), internalformat_(internalformat) {
-}
-
-GLImageLinuxDMABuffer::~GLImageLinuxDMABuffer() {
-}
-
-bool GLImageLinuxDMABuffer::Initialize(const base::FileDescriptor& handle,
-                                       GpuMemoryBuffer::Format format,
-                                       int pitch) {
-  if (!ValidInternalFormat(internalformat_)) {
-    LOG(ERROR) << "Invalid internalformat: " << internalformat_;
-    return false;
-  }
-
-  if (!ValidFormat(format)) {
-    LOG(ERROR) << "Invalid format: " << format;
-    return false;
-  }
-
-  if (!IsHandleValid(handle)) {
-    LOG(ERROR) << "Invalid file descriptor: " << handle.fd;
-    return false;
-  }
-
-  // Note: If eglCreateImageKHR is successful for a EGL_LINUX_DMA_BUF_EXT
-  // target, the EGL will take a reference to the dma_buf.
-  EGLint attrs[] = {EGL_WIDTH,
-                    size_.width(),
-                    EGL_HEIGHT,
-                    size_.height(),
-                    EGL_LINUX_DRM_FOURCC_EXT,
-                    FourCC(format),
-                    EGL_DMA_BUF_PLANE0_FD_EXT,
-                    handle.fd,
-                    EGL_DMA_BUF_PLANE0_OFFSET_EXT,
-                    0,
-                    EGL_DMA_BUF_PLANE0_PITCH_EXT,
-                    pitch,
-                    EGL_NONE};
-  return GLImageEGL::Initialize(
-      EGL_LINUX_DMA_BUF_EXT, static_cast<EGLClientBuffer>(NULL), attrs);
-}
-
-unsigned GLImageLinuxDMABuffer::GetInternalFormat() { return internalformat_; }
-
-}  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_linux_dma_buffer.h b/chromium/ui/gl/gl_image_linux_dma_buffer.h
deleted file mode 100644
index 92710bc2cc8..00000000000
--- a/chromium/ui/gl/gl_image_linux_dma_buffer.h
+++ /dev/null
@@ -1,37 +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_IMAGE_LINUX_DMA_BUFFER_H_
-#define UI_GL_GL_IMAGE_LINUX_DMA_BUFFER_H_
-
-#include "ui/gfx/gpu_memory_buffer.h"
-#include "ui/gl/gl_image_egl.h"
-
-namespace gfx {
-
-class GL_EXPORT GLImageLinuxDMABuffer : public GLImageEGL {
- public:
-  GLImageLinuxDMABuffer(const Size& size, unsigned internalformat);
-
-  // Returns true on success and the file descriptor can be closed as the
-  // implementation will take a reference to the dma_buf.
-  bool Initialize(const base::FileDescriptor& handle,
-                  GpuMemoryBuffer::Format format,
-                  int pitch);
-
-  // Overridden from GLImage:
-  unsigned GetInternalFormat() override;
-
- protected:
-  ~GLImageLinuxDMABuffer() override;
-
- private:
-  unsigned internalformat_;
-
-  DISALLOW_COPY_AND_ASSIGN(GLImageLinuxDMABuffer);
-};
-
-}  // namespace gfx
-
-#endif  // UI_GL_GL_IMAGE_LINUX_DMA_BUFFER_H_
diff --git a/chromium/ui/gl/gl_image_memory.cc b/chromium/ui/gl/gl_image_memory.cc
index 5ccb9d160f8..c91ad5635f9 100644
--- a/chromium/ui/gl/gl_image_memory.cc
+++ b/chromium/ui/gl/gl_image_memory.cc
@@ -33,20 +33,22 @@ bool ValidInternalFormat(unsigned internalformat) {
   }
 }
 
-bool ValidFormat(GpuMemoryBuffer::Format format) {
+bool ValidFormat(BufferFormat format) {
   switch (format) {
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::R_8:
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::BGRA_8888:
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::R_8:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRA_8888:
       return true;
-    case GpuMemoryBuffer::RGBX_8888:
-    case GpuMemoryBuffer::YUV_420:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
       return false;
   }
 
@@ -54,20 +56,22 @@ bool ValidFormat(GpuMemoryBuffer::Format format) {
   return false;
 }
 
-bool IsCompressedFormat(GpuMemoryBuffer::Format format) {
+bool IsCompressedFormat(BufferFormat format) {
   switch (format) {
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::YUV_420:
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
       return true;
-    case GpuMemoryBuffer::R_8:
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::BGRA_8888:
-    case GpuMemoryBuffer::RGBX_8888:
+    case BufferFormat::R_8:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
       return false;
   }
 
@@ -75,27 +79,29 @@ bool IsCompressedFormat(GpuMemoryBuffer::Format format) {
   return false;
 }
 
-GLenum TextureFormat(GpuMemoryBuffer::Format format) {
+GLenum TextureFormat(BufferFormat format) {
   switch (format) {
-    case GpuMemoryBuffer::ATC:
+    case BufferFormat::ATC:
       return GL_ATC_RGB_AMD;
-    case GpuMemoryBuffer::ATCIA:
+    case BufferFormat::ATCIA:
       return GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;
-    case GpuMemoryBuffer::DXT1:
+    case BufferFormat::DXT1:
       return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
-    case GpuMemoryBuffer::DXT5:
+    case BufferFormat::DXT5:
       return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
-    case GpuMemoryBuffer::ETC1:
+    case BufferFormat::ETC1:
       return GL_ETC1_RGB8_OES;
-    case GpuMemoryBuffer::R_8:
+    case BufferFormat::R_8:
       return GL_RED;
-    case GpuMemoryBuffer::RGBA_4444:
-    case GpuMemoryBuffer::RGBA_8888:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
       return GL_RGBA;
-    case GpuMemoryBuffer::BGRA_8888:
+    case BufferFormat::BGRA_8888:
       return GL_BGRA_EXT;
-    case GpuMemoryBuffer::RGBX_8888:
-    case GpuMemoryBuffer::YUV_420:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
       NOTREACHED();
       return 0;
   }
@@ -104,25 +110,27 @@ GLenum TextureFormat(GpuMemoryBuffer::Format format) {
   return 0;
 }
 
-GLenum DataFormat(GpuMemoryBuffer::Format format) {
+GLenum DataFormat(BufferFormat format) {
   return TextureFormat(format);
 }
 
-GLenum DataType(GpuMemoryBuffer::Format format) {
+GLenum DataType(BufferFormat format) {
   switch (format) {
-    case GpuMemoryBuffer::RGBA_4444:
+    case BufferFormat::RGBA_4444:
       return GL_UNSIGNED_SHORT_4_4_4_4;
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::BGRA_8888:
-    case GpuMemoryBuffer::R_8:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::R_8:
       return GL_UNSIGNED_BYTE;
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::DXT5:
-    case GpuMemoryBuffer::ETC1:
-    case GpuMemoryBuffer::RGBX_8888:
-    case GpuMemoryBuffer::YUV_420:
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
       NOTREACHED();
       return 0;
   }
@@ -131,8 +139,7 @@ GLenum DataType(GpuMemoryBuffer::Format format) {
   return 0;
 }
 
-GLsizei SizeInBytes(const Size& size,
-                    GpuMemoryBuffer::Format format) {
+GLsizei SizeInBytes(const Size& size, BufferFormat format) {
   size_t stride_in_bytes = 0;
   bool valid_stride = GLImageMemory::StrideInBytes(
       size.width(), format, &stride_in_bytes);
@@ -146,7 +153,7 @@ GLImageMemory::GLImageMemory(const Size& size, unsigned internalformat)
     : size_(size),
       internalformat_(internalformat),
       memory_(NULL),
-      format_(GpuMemoryBuffer::RGBA_8888),
+      format_(BufferFormat::RGBA_8888),
       in_use_(false),
       target_(0),
       need_do_bind_tex_image_(false)
@@ -169,41 +176,43 @@ GLImageMemory::~GLImageMemory() {
 
 // static
 bool GLImageMemory::StrideInBytes(size_t width,
-                                  GpuMemoryBuffer::Format format,
+                                  BufferFormat format,
                                   size_t* stride_in_bytes) {
   base::CheckedNumeric<size_t> checked_stride = width;
   switch (format) {
-    case GpuMemoryBuffer::ATCIA:
-    case GpuMemoryBuffer::DXT5:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT5:
       *stride_in_bytes = width;
       return true;
-    case GpuMemoryBuffer::ATC:
-    case GpuMemoryBuffer::DXT1:
-    case GpuMemoryBuffer::ETC1:
+    case BufferFormat::ATC:
+    case BufferFormat::DXT1:
+    case BufferFormat::ETC1:
       DCHECK_EQ(width % 2, 0u);
       *stride_in_bytes = width / 2;
       return true;
-    case GpuMemoryBuffer::R_8:
+    case BufferFormat::R_8:
       checked_stride += 3;
       if (!checked_stride.IsValid())
         return false;
       *stride_in_bytes = checked_stride.ValueOrDie() & ~0x3;
       return true;
-    case GpuMemoryBuffer::RGBA_4444:
+    case BufferFormat::RGBA_4444:
       checked_stride *= 2;
       if (!checked_stride.IsValid())
         return false;
       *stride_in_bytes = checked_stride.ValueOrDie();
       return true;
-    case GpuMemoryBuffer::RGBA_8888:
-    case GpuMemoryBuffer::BGRA_8888:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRA_8888:
       checked_stride *= 4;
       if (!checked_stride.IsValid())
         return false;
       *stride_in_bytes = checked_stride.ValueOrDie();
       return true;
-    case GpuMemoryBuffer::RGBX_8888:
-    case GpuMemoryBuffer::YUV_420:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
       NOTREACHED();
       return false;
   }
@@ -213,14 +222,14 @@ bool GLImageMemory::StrideInBytes(size_t width,
 }
 
 bool GLImageMemory::Initialize(const unsigned char* memory,
-                               GpuMemoryBuffer::Format format) {
+                               BufferFormat format) {
   if (!ValidInternalFormat(internalformat_)) {
     LOG(ERROR) << "Invalid internalformat: " << internalformat_;
     return false;
   }
 
   if (!ValidFormat(format)) {
-    LOG(ERROR) << "Invalid format: " << format;
+    LOG(ERROR) << "Invalid format: " << static_cast<int>(format);
     return false;
   }
 
@@ -439,4 +448,30 @@ void GLImageMemory::DoBindTexImage(unsigned target) {
   }
 }
 
+void GLImageMemory::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                                 uint64_t process_tracing_id,
+                                 const std::string& dump_name) {
+  // Note that the following calculation does not consider whether this GLImage
+  // has been un-bound from a texture. It also relies on this GLImage only ever
+  // being bound to a single texture. We could check these conditions more
+  // thoroughly, but at the cost of extra GL queries.
+  bool is_bound_to_texture = target_ && !need_do_bind_tex_image_;
+
+#if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
+    defined(USE_OZONE)
+  is_bound_to_texture |= !!egl_texture_id_;
+#endif
+
+  size_t size_in_bytes = is_bound_to_texture ? SizeInBytes(size_, format_) : 0;
+
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump(dump_name + "/texture_memory");
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  static_cast<uint64_t>(size_in_bytes));
+
+  // No need for a global shared edge here. This object in the GPU process is
+  // the sole owner of this texture id.
+}
+
 }  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_memory.h b/chromium/ui/gl/gl_image_memory.h
index 89ccfa7eab6..10b1a3bc60b 100644
--- a/chromium/ui/gl/gl_image_memory.h
+++ b/chromium/ui/gl/gl_image_memory.h
@@ -23,11 +23,10 @@ class GL_EXPORT GLImageMemory : public GLImage {
   GLImageMemory(const Size& size, unsigned internalformat);
 
   static bool StrideInBytes(size_t width,
-                            GpuMemoryBuffer::Format format,
+                            BufferFormat format,
                             size_t* stride_in_bytes);
 
-  bool Initialize(const unsigned char* memory,
-                  GpuMemoryBuffer::Format format);
+  bool Initialize(const unsigned char* memory, BufferFormat format);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
@@ -48,16 +47,24 @@ class GL_EXPORT GLImageMemory : public GLImage {
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
 
+  // Only dumps the GLTexture portion of the memory usage. Subclasses are
+  // responsible for dumping the CPU-side memory.
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
+
  protected:
   ~GLImageMemory() override;
 
+  BufferFormat format() const { return format_; }
+
  private:
   void DoBindTexImage(unsigned target);
 
   const Size size_;
   const unsigned internalformat_;
   const unsigned char* memory_;
-  GpuMemoryBuffer::Format format_;
+  BufferFormat format_;
   bool in_use_;
   unsigned target_;
   bool need_do_bind_tex_image_;
diff --git a/chromium/ui/gl/gl_image_ozone_native_pixmap.cc b/chromium/ui/gl/gl_image_ozone_native_pixmap.cc
new file mode 100644
index 00000000000..413c0abe460
--- /dev/null
+++ b/chromium/ui/gl/gl_image_ozone_native_pixmap.cc
@@ -0,0 +1,153 @@
+// 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/gl_image_ozone_native_pixmap.h"
+
+#define FOURCC(a, b, c, d)                                    \
+  ((static_cast<uint32>(a)) | (static_cast<uint32>(b) << 8) | \
+   (static_cast<uint32>(c) << 16) | (static_cast<uint32>(d) << 24))
+
+#define DRM_FORMAT_ARGB8888 FOURCC('A', 'R', '2', '4')
+#define DRM_FORMAT_XRGB8888 FOURCC('X', 'R', '2', '4')
+
+namespace gfx {
+namespace {
+
+bool ValidInternalFormat(unsigned internalformat) {
+  switch (internalformat) {
+    case GL_RGB:
+    case GL_BGRA_EXT:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool ValidFormat(gfx::BufferFormat format) {
+  switch (format) {
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::BGRX_8888:
+      return true;
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::R_8:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
+      return false;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
+EGLint FourCC(gfx::BufferFormat format) {
+  switch (format) {
+    case BufferFormat::BGRA_8888:
+      return DRM_FORMAT_ARGB8888;
+    case BufferFormat::BGRX_8888:
+      return DRM_FORMAT_XRGB8888;
+    case BufferFormat::ATC:
+    case BufferFormat::ATCIA:
+    case BufferFormat::DXT1:
+    case BufferFormat::DXT5:
+    case BufferFormat::ETC1:
+    case BufferFormat::R_8:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::UYVY_422:
+      NOTREACHED();
+      return 0;
+  }
+
+  NOTREACHED();
+  return 0;
+}
+
+}  // namespace
+
+GLImageOzoneNativePixmap::GLImageOzoneNativePixmap(const Size& size,
+                                                   unsigned internalformat)
+    : GLImageEGL(size), internalformat_(internalformat) {}
+
+GLImageOzoneNativePixmap::~GLImageOzoneNativePixmap() {
+}
+
+bool GLImageOzoneNativePixmap::Initialize(ui::NativePixmap* pixmap,
+                                          BufferFormat format) {
+  DCHECK(!pixmap_);
+
+  bool result = true;
+  if (pixmap->GetEGLClientBuffer()) {
+    EGLint attrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
+    result = GLImageEGL::Initialize(EGL_NATIVE_PIXMAP_KHR,
+                                    pixmap->GetEGLClientBuffer(), attrs);
+  } else if (pixmap->GetDmaBufFd() >= 0) {
+    if (!ValidInternalFormat(internalformat_)) {
+      LOG(ERROR) << "Invalid internalformat: " << internalformat_;
+      return false;
+    }
+
+    if (!ValidFormat(format)) {
+      LOG(ERROR) << "Invalid format: " << static_cast<int>(format);
+      return false;
+    }
+
+    // Note: If eglCreateImageKHR is successful for a EGL_LINUX_DMA_BUF_EXT
+    // target, the EGL will take a reference to the dma_buf.
+    EGLint attrs[] = {EGL_WIDTH,
+                      size_.width(),
+                      EGL_HEIGHT,
+                      size_.height(),
+                      EGL_LINUX_DRM_FOURCC_EXT,
+                      FourCC(format),
+                      EGL_DMA_BUF_PLANE0_FD_EXT,
+                      pixmap->GetDmaBufFd(),
+                      EGL_DMA_BUF_PLANE0_OFFSET_EXT,
+                      0,
+                      EGL_DMA_BUF_PLANE0_PITCH_EXT,
+                      pixmap->GetDmaBufPitch(),
+                      EGL_NONE};
+    result = GLImageEGL::Initialize(
+        EGL_LINUX_DMA_BUF_EXT, static_cast<EGLClientBuffer>(nullptr), attrs);
+  }
+
+  if (result)
+    pixmap_ = pixmap;
+  return result;
+}
+
+unsigned GLImageOzoneNativePixmap::GetInternalFormat() {
+  return internalformat_;
+}
+
+void GLImageOzoneNativePixmap::Destroy(bool have_context) {
+  GLImageEGL::Destroy(have_context);
+}
+
+bool GLImageOzoneNativePixmap::ScheduleOverlayPlane(AcceleratedWidget widget,
+                                                    int z_order,
+                                                    OverlayTransform transform,
+                                                    const Rect& bounds_rect,
+                                                    const RectF& crop_rect) {
+  DCHECK(pixmap_);
+  return pixmap_->ScheduleOverlayPlane(widget, z_order, transform, bounds_rect,
+                                       crop_rect);
+}
+
+void GLImageOzoneNativePixmap::OnMemoryDump(
+    base::trace_event::ProcessMemoryDump* pmd,
+    uint64_t process_tracing_id,
+    const std::string& dump_name) {
+  // TODO(ericrk): Implement GLImage OnMemoryDump. crbug.com/514914
+}
+
+}  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_ozone_native_pixmap.h b/chromium/ui/gl/gl_image_ozone_native_pixmap.h
new file mode 100644
index 00000000000..e164f39c2c3
--- /dev/null
+++ b/chromium/ui/gl/gl_image_ozone_native_pixmap.h
@@ -0,0 +1,42 @@
+// 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_GL_IMAGE_OZONE_NATIVE_PIXMAP_H_
+#define UI_GL_GL_IMAGE_OZONE_NATIVE_PIXMAP_H_
+
+#include "ui/gfx/gpu_memory_buffer.h"
+#include "ui/gl/gl_image_egl.h"
+#include "ui/ozone/public/native_pixmap.h"
+
+namespace gfx {
+
+class GL_EXPORT GLImageOzoneNativePixmap : public GLImageEGL {
+ public:
+  GLImageOzoneNativePixmap(const Size& size, unsigned internalformat);
+
+  bool Initialize(ui::NativePixmap* pixmap, BufferFormat format);
+
+  // Overridden from GLImage:
+  unsigned GetInternalFormat() override;
+  void Destroy(bool have_context) override;
+  bool ScheduleOverlayPlane(AcceleratedWidget widget,
+                            int z_order,
+                            OverlayTransform transform,
+                            const Rect& bounds_rect,
+                            const RectF& crop_rect) override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
+
+ protected:
+  ~GLImageOzoneNativePixmap() override;
+
+ private:
+  unsigned internalformat_;
+  scoped_refptr<ui::NativePixmap> pixmap_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GL_GL_IMAGE_OZONE_NATIVE_PIXMAP_H_
diff --git a/chromium/ui/gl/gl_image_ref_counted_memory.cc b/chromium/ui/gl/gl_image_ref_counted_memory.cc
index 653d70a98c7..7aadd247e94 100644
--- a/chromium/ui/gl/gl_image_ref_counted_memory.cc
+++ b/chromium/ui/gl/gl_image_ref_counted_memory.cc
@@ -20,7 +20,7 @@ GLImageRefCountedMemory::~GLImageRefCountedMemory() {
 
 bool GLImageRefCountedMemory::Initialize(
     base::RefCountedMemory* ref_counted_memory,
-    gfx::GpuMemoryBuffer::Format format) {
+    gfx::BufferFormat format) {
   if (!GLImageMemory::Initialize(ref_counted_memory->front(), format))
     return false;
 
@@ -34,4 +34,27 @@ void GLImageRefCountedMemory::Destroy(bool have_context) {
   ref_counted_memory_ = NULL;
 }
 
+void GLImageRefCountedMemory::OnMemoryDump(
+    base::trace_event::ProcessMemoryDump* pmd,
+    uint64_t process_tracing_id,
+    const std::string& dump_name) {
+  // Log size 0 if |ref_counted_memory_| has been released.
+  size_t size_in_bytes = ref_counted_memory_ ? ref_counted_memory_->size() : 0;
+
+  // Dump under "/private_memory", as the base class may also dump to
+  // "/texture_memory".
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump(dump_name + "/private_memory");
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  static_cast<uint64_t>(size_in_bytes));
+
+  pmd->AddSuballocation(dump->guid(),
+                        base::trace_event::MemoryDumpManager::GetInstance()
+                            ->system_allocator_pool_name());
+
+  // Also dump the base class's texture memory.
+  GLImageMemory::OnMemoryDump(pmd, process_tracing_id, dump_name);
+}
+
 }  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_ref_counted_memory.h b/chromium/ui/gl/gl_image_ref_counted_memory.h
index 6bcf2179f26..db079545dac 100644
--- a/chromium/ui/gl/gl_image_ref_counted_memory.h
+++ b/chromium/ui/gl/gl_image_ref_counted_memory.h
@@ -19,10 +19,13 @@ class GL_EXPORT GLImageRefCountedMemory : public GLImageMemory {
   GLImageRefCountedMemory(const gfx::Size& size, unsigned internalformat);
 
   bool Initialize(base::RefCountedMemory* ref_counted_memory,
-                  gfx::GpuMemoryBuffer::Format format);
+                  gfx::BufferFormat format);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
 
  protected:
   ~GLImageRefCountedMemory() override;
diff --git a/chromium/ui/gl/gl_image_shared_memory.cc b/chromium/ui/gl/gl_image_shared_memory.cc
index d9e31a73ae5..33ba4d161ab 100644
--- a/chromium/ui/gl/gl_image_shared_memory.cc
+++ b/chromium/ui/gl/gl_image_shared_memory.cc
@@ -13,7 +13,7 @@ namespace {
 
 // Returns true if the size is valid and false otherwise.
 bool SizeInBytes(const gfx::Size& size,
-                 gfx::GpuMemoryBuffer::Format format,
+                 gfx::BufferFormat format,
                  size_t* size_in_bytes) {
   if (size.IsEmpty())
     return false;
@@ -41,7 +41,7 @@ GLImageSharedMemory::~GLImageSharedMemory() {
 }
 
 bool GLImageSharedMemory::Initialize(const gfx::GpuMemoryBufferHandle& handle,
-                                     gfx::GpuMemoryBuffer::Format format) {
+                                     gfx::BufferFormat format) {
   size_t size_in_bytes;
   if (!SizeInBytes(GetSize(), format, &size_in_bytes))
     return false;
@@ -73,6 +73,7 @@ bool GLImageSharedMemory::Initialize(const gfx::GpuMemoryBufferHandle& handle,
 
   DCHECK(!shared_memory_);
   shared_memory_ = duped_shared_memory.Pass();
+  shared_memory_id_ = handle.id;
   return true;
 }
 
@@ -81,4 +82,32 @@ void GLImageSharedMemory::Destroy(bool have_context) {
   shared_memory_.reset();
 }
 
+void GLImageSharedMemory::OnMemoryDump(
+    base::trace_event::ProcessMemoryDump* pmd,
+    uint64_t process_tracing_id,
+    const std::string& dump_name) {
+  size_t size_in_bytes = 0;
+
+  if (shared_memory_) {
+    bool result = SizeInBytes(GetSize(), format(), &size_in_bytes);
+    DCHECK(result);
+  }
+
+  // Dump under "/shared_memory", as the base class may also dump to
+  // "/texture_memory".
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump(dump_name + "/private_memory");
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  static_cast<uint64_t>(size_in_bytes));
+
+  auto guid = gfx::GetGenericSharedMemoryGUIDForTracing(process_tracing_id,
+                                                        shared_memory_id_);
+  pmd->CreateSharedGlobalAllocatorDump(guid);
+  pmd->AddOwnershipEdge(dump->guid(), guid);
+
+  // Also dump the base class's texture memory.
+  GLImageMemory::OnMemoryDump(pmd, process_tracing_id, dump_name);
+}
+
 }  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_shared_memory.h b/chromium/ui/gl/gl_image_shared_memory.h
index ab80b35bc59..d9233cb1fc3 100644
--- a/chromium/ui/gl/gl_image_shared_memory.h
+++ b/chromium/ui/gl/gl_image_shared_memory.h
@@ -16,16 +16,20 @@ class GL_EXPORT GLImageSharedMemory : public GLImageMemory {
   GLImageSharedMemory(const gfx::Size& size, unsigned internalformat);
 
   bool Initialize(const gfx::GpuMemoryBufferHandle& handle,
-                  gfx::GpuMemoryBuffer::Format format);
+                  gfx::BufferFormat format);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
 
  protected:
   ~GLImageSharedMemory() override;
 
  private:
   scoped_ptr<base::SharedMemory> shared_memory_;
+  gfx::GenericSharedMemoryId shared_memory_id_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageSharedMemory);
 };
diff --git a/chromium/ui/gl/gl_image_stub.h b/chromium/ui/gl/gl_image_stub.h
index 04c760b945e..be31bff5afc 100644
--- a/chromium/ui/gl/gl_image_stub.h
+++ b/chromium/ui/gl/gl_image_stub.h
@@ -32,6 +32,9 @@ class GL_EXPORT GLImageStub : public GLImage {
                             OverlayTransform transform,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override {}
 
  protected:
   ~GLImageStub() override;
diff --git a/chromium/ui/gl/gl_image_surface_texture.cc b/chromium/ui/gl/gl_image_surface_texture.cc
index bec06be8f24..910551da3a4 100644
--- a/chromium/ui/gl/gl_image_surface_texture.cc
+++ b/chromium/ui/gl/gl_image_surface_texture.cc
@@ -92,4 +92,11 @@ bool GLImageSurfaceTexture::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
   return false;
 }
 
+void GLImageSurfaceTexture::OnMemoryDump(
+    base::trace_event::ProcessMemoryDump* pmd,
+    uint64_t process_tracing_id,
+    const std::string& dump_name) {
+  // TODO(ericrk): Add OnMemoryDump for GLImages. crbug.com/514914
+}
+
 }  // namespace gfx
diff --git a/chromium/ui/gl/gl_image_surface_texture.h b/chromium/ui/gl/gl_image_surface_texture.h
index 2412c5d0101..d8c4abb360a 100644
--- a/chromium/ui/gl/gl_image_surface_texture.h
+++ b/chromium/ui/gl/gl_image_surface_texture.h
@@ -37,6 +37,9 @@ class GL_EXPORT GLImageSurfaceTexture : public GLImage {
                             OverlayTransform transform,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override;
 
  protected:
   ~GLImageSurfaceTexture() override;
diff --git a/chromium/ui/gl/gl_implementation.cc b/chromium/ui/gl/gl_implementation.cc
index 4fae0ec5302..66f228243fc 100644
--- a/chromium/ui/gl/gl_implementation.cc
+++ b/chromium/ui/gl/gl_implementation.cc
@@ -14,6 +14,7 @@
 #include "base/strings/string_util.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_version_info.h"
 
 namespace gfx {
 
@@ -162,8 +163,8 @@ std::string FilterGLExtensionList(
   if (extensions == NULL)
     return "";
 
-  std::vector<std::string> extension_vec;
-  base::SplitString(extensions, ' ', &extension_vec);
+  std::vector<std::string> extension_vec = base::SplitString(
+      extensions, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   auto is_disabled = [&disabled_extensions](const std::string& ext) {
     return std::find(disabled_extensions.begin(), disabled_extensions.end(),
@@ -173,7 +174,7 @@ std::string FilterGLExtensionList(
       std::remove_if(extension_vec.begin(), extension_vec.end(), is_disabled),
       extension_vec.end());
 
-  return JoinString(extension_vec, " ");
+  return base::JoinString(extension_vec, " ");
 }
 
 DisableNullDrawGLBindings::DisableNullDrawGLBindings() {
@@ -187,4 +188,31 @@ DisableNullDrawGLBindings::~DisableNullDrawGLBindings() {
 GLWindowSystemBindingInfo::GLWindowSystemBindingInfo()
     : direct_rendering(true) {}
 
+std::string GetGLExtensionsFromCurrentContext() {
+  if (WillUseGLGetStringForExtensions()) {
+    return reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
+  }
+
+  std::vector<std::string> exts;
+  GLint num_extensions = 0;
+  glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
+  for (GLint i = 0; i < num_extensions; ++i) {
+    const char* extension = reinterpret_cast<const char*>(
+        glGetStringi(GL_EXTENSIONS, i));
+    DCHECK(extension != NULL);
+    exts.push_back(extension);
+  }
+  return base::JoinString(exts, " ");
+}
+
+bool WillUseGLGetStringForExtensions() {
+  const char* version_str =
+      reinterpret_cast<const char*>(glGetString(GL_VERSION));
+  unsigned major_version, minor_version;
+  bool is_es, is_es3;
+  gfx::GLVersionInfo::ParseVersionString(
+      version_str, &major_version, &minor_version, &is_es, &is_es3);
+  return is_es || major_version < 3;
+}
+
 }  // namespace gfx
diff --git a/chromium/ui/gl/gl_implementation.h b/chromium/ui/gl/gl_implementation.h
index c0ac42ea429..eab70dc3598 100644
--- a/chromium/ui/gl/gl_implementation.h
+++ b/chromium/ui/gl/gl_implementation.h
@@ -36,7 +36,8 @@ struct GL_EXPORT GLWindowSystemBindingInfo {
   bool direct_rendering;
 };
 
-void GetAllowedGLImplementations(std::vector<GLImplementation>* impls);
+void GL_EXPORT
+GetAllowedGLImplementations(std::vector<GLImplementation>* impls);
 
 #if defined(OS_WIN)
 typedef void* (WINAPI *GLGetProcAddressProc)(const char* name);
@@ -121,6 +122,19 @@ void* GetGLProcAddress(const char* name);
 // EGL, GLX, WGL). Returns true if the information was retrieved successfully.
 GL_EXPORT bool GetGLWindowSystemBindingInfo(GLWindowSystemBindingInfo* info);
 
+// Helper for fetching the OpenGL extensions from the current context.
+// This helper abstracts over differences between the desktop OpenGL
+// core profile, and OpenGL ES and the compatibility profile.  It's
+// intended for users of the bindings, not the implementation of the
+// bindings themselves. This is a relatively expensive call, so
+// callers should cache the result.
+GL_EXPORT std::string GetGLExtensionsFromCurrentContext();
+
+// 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();
+
 }  // namespace gfx
 
 #endif  // UI_GL_GL_IMPLEMENTATION_H_
diff --git a/chromium/ui/gl/gl_implementation_win.cc b/chromium/ui/gl/gl_implementation_win.cc
index 40cbdde9131..6a4e61298a7 100644
--- a/chromium/ui/gl/gl_implementation_win.cc
+++ b/chromium/ui/gl/gl_implementation_win.cc
@@ -90,16 +90,17 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
   switch (implementation) {
     case kGLImplementationOSMesaGL: {
       base::FilePath module_path;
-      if (!PathService::Get(base::DIR_MODULE, &module_path)) {
-        LOG(ERROR) << "PathService::Get failed.";
-        return false;
-      }
-
+      PathService::Get(base::DIR_MODULE, &module_path);
       base::NativeLibrary library = base::LoadNativeLibrary(
           module_path.Append(L"osmesa.dll"), NULL);
       if (!library) {
-        DVLOG(1) << "osmesa.dll not found";
-        return false;
+        PathService::Get(base::DIR_EXE, &module_path);
+        library = base::LoadNativeLibrary(
+            module_path.Append(L"osmesa.dll"), NULL);
+        if (!library) {
+          DVLOG(1) << "osmesa.dll not found";
+          return false;
+        }
       }
 
       GLGetProcAddressProc get_proc_address =
diff --git a/chromium/ui/gl/gl_mock_autogen_gl.h b/chromium/ui/gl/gl_mock_autogen_gl.h
index 2840661c996..53c49dff775 100644
--- a/chromium/ui/gl/gl_mock_autogen_gl.h
+++ b/chromium/ui/gl/gl_mock_autogen_gl.h
@@ -9,6 +9,7 @@
 // DO NOT EDIT!
 
 MOCK_METHOD1(ActiveTexture, void(GLenum texture));
+MOCK_METHOD0(ApplyFramebufferAttachmentCMAAINTEL, void());
 MOCK_METHOD2(AttachShader, void(GLuint program, GLuint shader));
 MOCK_METHOD2(BeginQuery, void(GLenum target, GLuint id));
 MOCK_METHOD1(BeginTransformFeedback, void(GLenum primitiveMode));
@@ -168,6 +169,8 @@ MOCK_METHOD9(CopyTexSubImage3D,
                   GLint y,
                   GLsizei width,
                   GLsizei height));
+MOCK_METHOD2(CoverFillPathNV, void(GLuint path, GLenum coverMode));
+MOCK_METHOD2(CoverStrokePathNV, void(GLuint name, GLenum coverMode));
 MOCK_METHOD0(CreateProgram, GLuint());
 MOCK_METHOD1(CreateShader, GLuint(GLenum type));
 MOCK_METHOD1(CullFace, void(GLenum mode));
@@ -176,6 +179,7 @@ MOCK_METHOD2(DeleteFencesAPPLE, void(GLsizei n, const GLuint* fences));
 MOCK_METHOD2(DeleteFencesNV, void(GLsizei n, const GLuint* fences));
 MOCK_METHOD2(DeleteFramebuffersEXT,
              void(GLsizei n, const GLuint* framebuffers));
+MOCK_METHOD2(DeletePathsNV, void(GLuint path, GLsizei range));
 MOCK_METHOD1(DeleteProgram, void(GLuint program));
 MOCK_METHOD2(DeleteQueries, void(GLsizei n, const GLuint* ids));
 MOCK_METHOD2(DeleteRenderbuffersEXT,
@@ -270,6 +274,7 @@ MOCK_METHOD1(GenerateMipmapEXT, void(GLenum target));
 MOCK_METHOD2(GenFencesAPPLE, void(GLsizei n, GLuint* fences));
 MOCK_METHOD2(GenFencesNV, void(GLsizei n, GLuint* fences));
 MOCK_METHOD2(GenFramebuffersEXT, void(GLsizei n, GLuint* framebuffers));
+MOCK_METHOD1(GenPathsNV, GLuint(GLsizei range));
 MOCK_METHOD2(GenQueries, void(GLsizei n, GLuint* ids));
 MOCK_METHOD2(GenRenderbuffersEXT, void(GLsizei n, GLuint* renderbuffers));
 MOCK_METHOD2(GenSamplers, void(GLsizei n, GLuint* samplers));
@@ -436,6 +441,7 @@ MOCK_METHOD1(IsEnabled, GLboolean(GLenum cap));
 MOCK_METHOD1(IsFenceAPPLE, GLboolean(GLuint fence));
 MOCK_METHOD1(IsFenceNV, GLboolean(GLuint fence));
 MOCK_METHOD1(IsFramebufferEXT, GLboolean(GLuint framebuffer));
+MOCK_METHOD1(IsPathNV, GLboolean(GLuint path));
 MOCK_METHOD1(IsProgram, GLboolean(GLuint program));
 MOCK_METHOD1(IsQuery, GLboolean(GLuint query));
 MOCK_METHOD1(IsRenderbufferEXT, GLboolean(GLuint renderbuffer));
@@ -455,6 +461,16 @@ MOCK_METHOD4(MapBufferRange,
                    GLbitfield access));
 MOCK_METHOD2(MatrixLoadfEXT, void(GLenum matrixMode, const GLfloat* m));
 MOCK_METHOD1(MatrixLoadIdentityEXT, void(GLenum matrixMode));
+MOCK_METHOD6(PathCommandsNV,
+             void(GLuint path,
+                  GLsizei numCommands,
+                  const GLubyte* commands,
+                  GLsizei numCoords,
+                  GLenum coordType,
+                  const GLvoid* coords));
+MOCK_METHOD3(PathParameterfNV, void(GLuint path, GLenum pname, GLfloat value));
+MOCK_METHOD3(PathParameteriNV, void(GLuint path, GLenum pname, GLint value));
+MOCK_METHOD3(PathStencilFuncNV, void(GLenum func, GLint ref, GLuint mask));
 MOCK_METHOD0(PauseTransformFeedback, void());
 MOCK_METHOD2(PixelStorei, void(GLenum pname, GLint param));
 MOCK_METHOD2(PointParameteri, void(GLenum pname, GLint param));
@@ -530,6 +546,8 @@ MOCK_METHOD4(ShaderSource,
                   GLsizei count,
                   const char* const* str,
                   const GLint* length));
+MOCK_METHOD3(StencilFillPathNV,
+             void(GLuint path, GLenum fillMode, GLuint mask));
 MOCK_METHOD3(StencilFunc, void(GLenum func, GLint ref, GLuint mask));
 MOCK_METHOD4(StencilFuncSeparate,
              void(GLenum face, GLenum func, GLint ref, GLuint mask));
@@ -538,6 +556,12 @@ MOCK_METHOD2(StencilMaskSeparate, void(GLenum face, GLuint mask));
 MOCK_METHOD3(StencilOp, void(GLenum fail, GLenum zfail, GLenum zpass));
 MOCK_METHOD4(StencilOpSeparate,
              void(GLenum face, GLenum fail, GLenum zfail, GLenum zpass));
+MOCK_METHOD3(StencilStrokePathNV,
+             void(GLuint path, GLint reference, GLuint mask));
+MOCK_METHOD4(StencilThenCoverFillPathNV,
+             void(GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode));
+MOCK_METHOD4(StencilThenCoverStrokePathNV,
+             void(GLuint path, GLint reference, GLuint mask, GLenum coverMode));
 MOCK_METHOD1(TestFenceAPPLE, GLboolean(GLuint fence));
 MOCK_METHOD1(TestFenceNV, GLboolean(GLuint fence));
 MOCK_METHOD9(TexImage2D,
diff --git a/chromium/ui/gl/gl_state_restorer.h b/chromium/ui/gl/gl_state_restorer.h
index 7edc9989134..87ad7cccb85 100644
--- a/chromium/ui/gl/gl_state_restorer.h
+++ b/chromium/ui/gl/gl_state_restorer.h
@@ -8,6 +8,12 @@
 #include "base/basictypes.h"
 #include "ui/gl/gl_export.h"
 
+namespace gpu {
+namespace gles2 {
+  class GLES2Decoder;
+}  // namespace gles2
+}  // namespace gpu
+
 namespace gfx {
 
 // An interface for Restoring GL State.
@@ -22,6 +28,8 @@ class GL_EXPORT GLStateRestorer {
   virtual void RestoreAllTextureUnitBindings() = 0;
   virtual void RestoreActiveTextureUnitBinding(unsigned int target) = 0;
   virtual void RestoreFramebufferBindings() = 0;
+  virtual void PauseQueries() = 0;
+  virtual void ResumeQueries() = 0;
 
   DISALLOW_COPY_AND_ASSIGN(GLStateRestorer);
 };
diff --git a/chromium/ui/gl/gl_surface.cc b/chromium/ui/gl/gl_surface.cc
index 8a60ca5477d..3c4538e66ee 100644
--- a/chromium/ui/gl/gl_surface.cc
+++ b/chromium/ui/gl/gl_surface.cc
@@ -17,10 +17,6 @@
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 
-#if defined(USE_X11)
-#include <X11/Xlib.h>
-#endif
-
 namespace gfx {
 
 namespace {
@@ -97,80 +93,12 @@ bool GLSurface::InitializeOneOffImplementation(GLImplementation impl,
   return initialized;
 }
 
-// static
-void GLSurface::InitializeOneOffForTests() {
-  DCHECK_EQ(kGLImplementationNone, GetGLImplementation());
-
-#if defined(USE_X11)
-  XInitThreads();
-#endif
-
-  bool use_osmesa = true;
-
-  // We usually use OSMesa as this works on all bots. The command line can
-  // override this behaviour to use hardware GL.
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUseGpuInTests))
-    use_osmesa = false;
-
-#if defined(OS_ANDROID)
-  // On Android we always use hardware GL.
-  use_osmesa = false;
-#endif
-
-  std::vector<GLImplementation> allowed_impls;
-  GetAllowedGLImplementations(&allowed_impls);
-  DCHECK(!allowed_impls.empty());
-
-  GLImplementation impl = allowed_impls[0];
-  if (use_osmesa)
-    impl = kGLImplementationOSMesaGL;
-
-  DCHECK(!base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseGL))
-      << "kUseGL has not effect in tests";
-
-  bool fallback_to_osmesa = false;
-  bool gpu_service_logging = false;
-  bool disable_gl_drawing = true;
-
-  CHECK(InitializeOneOffImplementation(
-      impl, fallback_to_osmesa, gpu_service_logging, disable_gl_drawing));
-}
-
-// static
-void GLSurface::InitializeOneOffWithMockBindingsForTests() {
-  DCHECK(!base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseGL))
-      << "kUseGL has not effect in tests";
-
-  // This method may be called multiple times in the same process to set up
-  // mock bindings in different ways.
-  ClearGLBindings();
-
-  bool fallback_to_osmesa = false;
-  bool gpu_service_logging = false;
-  bool disable_gl_drawing = false;
-
-  CHECK(InitializeOneOffImplementation(kGLImplementationMockGL,
-                                       fallback_to_osmesa,
-                                       gpu_service_logging,
-                                       disable_gl_drawing));
-}
-
-// static
-void GLSurface::InitializeDynamicMockBindingsForTests(GLContext* context) {
-  CHECK(InitializeDynamicGLBindings(kGLImplementationMockGL, context));
-}
-
 GLSurface::GLSurface() {}
 
 bool GLSurface::Initialize() {
   return true;
 }
 
-void GLSurface::DestroyAndTerminateDisplay() {
-  Destroy();
-}
-
 bool GLSurface::Resize(const gfx::Size& size) {
   NOTIMPLEMENTED();
   return false;
diff --git a/chromium/ui/gl/gl_surface.h b/chromium/ui/gl/gl_surface.h
index 9fee0a37c2c..5d98253910d 100644
--- a/chromium/ui/gl/gl_surface.h
+++ b/chromium/ui/gl/gl_surface.h
@@ -40,10 +40,6 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
   // Destroys the surface.
   virtual void Destroy() = 0;
 
-  // Destroys the surface and terminates its underlying display. This must be
-  // the last surface which uses the display.
-  virtual void DestroyAndTerminateDisplay();
-
   virtual bool Resize(const gfx::Size& size);
 
   // Recreate the surface without changing the size.
@@ -99,12 +95,6 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
   // Initialize GL bindings.
   static bool InitializeOneOff();
 
-  // Unit tests should call these instead of InitializeOneOff() to set up
-  // GL bindings appropriate for tests.
-  static void InitializeOneOffForTests();
-  static void InitializeOneOffWithMockBindingsForTests();
-  static void InitializeDynamicMockBindingsForTests(GLContext* context);
-
   // Called after a context is made current with this surface. Returns false
   // on error.
   virtual bool OnMakeCurrent(GLContext* context);
@@ -189,6 +179,7 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
  private:
   friend class base::RefCounted<GLSurface>;
   friend class GLContext;
+  friend class GLSurfaceTestSupport;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurface);
 };
diff --git a/chromium/ui/gl/gl_surface_egl.cc b/chromium/ui/gl/gl_surface_egl.cc
index 2e193a5d5dc..f85258ff8b8 100644
--- a/chromium/ui/gl/gl_surface_egl.cc
+++ b/chromium/ui/gl/gl_surface_egl.cc
@@ -85,16 +85,7 @@ namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
-EGLNativeDisplayType g_native_display_type;
-
-// In the Cast environment, we need to destroy the EGLNativeDisplayType and
-// EGLDisplay returned by the GPU platform when we switch to an external app
-// which will temporarily own all screen and GPU resources.
-// Even though Chromium is still in the background.
-// As such, it must be reinitialized each time we come back to the foreground.
-bool g_initialized = false;
-int g_num_surfaces = 0;
-bool g_terminate_pending = false;
+EGLNativeDisplayType g_native_display;
 
 const char* g_egl_extensions = NULL;
 bool g_egl_create_context_robustness_supported = false;
@@ -138,13 +129,6 @@ class EGLSyncControlVSyncProvider
   DISALLOW_COPY_AND_ASSIGN(EGLSyncControlVSyncProvider);
 };
 
-void DeinitializeEgl() {
-  if (g_initialized) {
-    g_initialized = false;
-    eglTerminate(g_display);
-  }
-}
-
 EGLDisplay GetPlatformANGLEDisplay(EGLNativeDisplayType native_display,
                                    EGLenum platform_type,
                                    bool warpDevice) {
@@ -270,17 +254,11 @@ void GetEGLInitDisplays(bool supports_angle_d3d,
   }
 }
 
-GLSurfaceEGL::GLSurfaceEGL() {
-  ++g_num_surfaces;
-  if (!g_initialized) {
-    bool result = GLSurfaceEGL::InitializeOneOff();
-    DCHECK(result);
-    DCHECK(g_initialized);
-  }
-}
+GLSurfaceEGL::GLSurfaceEGL() {}
 
 bool GLSurfaceEGL::InitializeOneOff() {
-  if (g_initialized)
+  static bool initialized = false;
+  if (initialized)
     return true;
 
   InitializeDisplay();
@@ -347,12 +325,6 @@ bool GLSurfaceEGL::InitializeOneOff() {
   g_egl_window_fixed_size_supported =
       HasEGLExtension("EGL_ANGLE_window_fixed_size");
 
-  // We always succeed beyond this point so set g_initialized here to avoid
-  // infinite recursion through CreateGLContext and GetDisplay
-  // if g_egl_surfaceless_context_supported.
-  g_initialized = true;
-  g_terminate_pending = false;
-
   // TODO(oetuaho@nvidia.com): Surfaceless is disabled on Android as a temporary
   // workaround, since code written for Android WebView takes different paths
   // based on whether GL surface objects have underlying EGL surface handles,
@@ -382,35 +354,24 @@ bool GLSurfaceEGL::InitializeOneOff() {
   }
 #endif
 
+  initialized = true;
+
   return true;
 }
 
 EGLDisplay GLSurfaceEGL::GetDisplay() {
-  DCHECK(g_initialized);
   return g_display;
 }
 
-// static
 EGLDisplay GLSurfaceEGL::GetHardwareDisplay() {
-  if (!g_initialized) {
-    bool result = GLSurfaceEGL::InitializeOneOff();
-    DCHECK(result);
-  }
   return g_display;
 }
 
-// static
 EGLNativeDisplayType GLSurfaceEGL::GetNativeDisplay() {
-  if (!g_initialized) {
-    bool result = GLSurfaceEGL::InitializeOneOff();
-    DCHECK(result);
-  }
-  return g_native_display_type;
+  return g_native_display;
 }
 
 const char* GLSurfaceEGL::GetEGLExtensions() {
-  // No need for InitializeOneOff. Assume that extensions will not change
-  // after the first initialization.
   return g_egl_extensions;
 }
 
@@ -426,20 +387,7 @@ bool GLSurfaceEGL::IsEGLSurfacelessContextSupported() {
   return g_egl_surfaceless_context_supported;
 }
 
-void GLSurfaceEGL::DestroyAndTerminateDisplay() {
-  DCHECK(g_initialized);
-  DCHECK_EQ(g_num_surfaces, 1);
-  Destroy();
-  g_terminate_pending = true;
-}
-
-GLSurfaceEGL::~GLSurfaceEGL() {
-  DCHECK_GT(g_num_surfaces, 0) << "Bad surface count";
-  if (--g_num_surfaces == 0 && g_terminate_pending) {
-    DeinitializeEgl();
-    g_terminate_pending = false;
-  }
-}
+GLSurfaceEGL::~GLSurfaceEGL() {}
 
 // InitializeDisplay is necessary because the static binding code
 // needs a full Display init before it can query the Display extensions.
@@ -449,7 +397,7 @@ EGLDisplay GLSurfaceEGL::InitializeDisplay() {
     return g_display;
   }
 
-  g_native_display_type = GetPlatformDefaultEGLNativeDisplay();
+  g_native_display = GetPlatformDefaultEGLNativeDisplay();
 
   // If EGL_EXT_client_extensions not supported this call to eglQueryString
   // will return NULL.
@@ -474,7 +422,7 @@ EGLDisplay GLSurfaceEGL::InitializeDisplay() {
   for (size_t disp_index = 0; disp_index < init_displays.size(); ++disp_index) {
     DisplayType display_type = init_displays[disp_index];
     EGLDisplay display =
-        GetDisplayFromType(display_type, g_native_display_type);
+        GetDisplayFromType(display_type, g_native_display);
     if (display == EGL_NO_DISPLAY) {
       LOG(ERROR) << "EGL display query failed with error "
                  << GetLastEGLErrorString();
diff --git a/chromium/ui/gl/gl_surface_egl.h b/chromium/ui/gl/gl_surface_egl.h
index 07d02712cb9..c8c7ddf3122 100644
--- a/chromium/ui/gl/gl_surface_egl.h
+++ b/chromium/ui/gl/gl_surface_egl.h
@@ -45,7 +45,6 @@ class GL_EXPORT GLSurfaceEGL : public GLSurface {
   GLSurfaceEGL();
 
   // Implement GLSurface.
-  void DestroyAndTerminateDisplay() override;
   EGLDisplay GetDisplay() override;
 
   static bool InitializeOneOff();
diff --git a/chromium/ui/gl/gl_surface_glx.cc b/chromium/ui/gl/gl_surface_glx.cc
index b021a426838..49ff0411507 100644
--- a/chromium/ui/gl/gl_surface_glx.cc
+++ b/chromium/ui/gl/gl_surface_glx.cc
@@ -47,7 +47,7 @@ bool g_glx_get_msc_rate_oml_supported = false;
 
 bool g_glx_sgi_video_sync_supported = false;
 
-static const base::TimeDelta kGetVSyncParametersMinPeriod =
+static const int kGetVSyncParametersMinSeconds =
 #if defined(OS_LINUX)
     // See crbug.com/373489
     // On Linux, querying the vsync parameters might burn CPU for up to an
@@ -55,9 +55,9 @@ static const base::TimeDelta kGetVSyncParametersMinPeriod =
     // 5 seconds is chosen somewhat abitrarily as a balance between:
     //  a) Drift in the phase of our signal.
     //  b) Potential janks from periodically pegging the CPU.
-    base::TimeDelta::FromSeconds(5);
+    5;
 #else
-    base::TimeDelta::FromSeconds(0);
+    0;
 #endif
 
 class OMLSyncControlVSyncProvider
@@ -261,10 +261,10 @@ class SGIVideoSyncVSyncProvider
 
   void GetVSyncParameters(
       const VSyncProvider::UpdateVSyncCallback& callback) override {
-    if (kGetVSyncParametersMinPeriod > base::TimeDelta()) {
+    if (kGetVSyncParametersMinSeconds > 0) {
       base::TimeTicks now = base::TimeTicks::Now();
       base::TimeDelta delta = now - last_get_vsync_parameters_time_;
-      if (delta < kGetVSyncParametersMinPeriod)
+      if (delta.InSeconds() < kGetVSyncParametersMinSeconds)
         return;
       last_get_vsync_parameters_time_ = now;
     }
diff --git a/chromium/ui/gl/gl_surface_ozone.cc b/chromium/ui/gl/gl_surface_ozone.cc
index 50a7326f66f..04fc760d366 100644
--- a/chromium/ui/gl/gl_surface_ozone.cc
+++ b/chromium/ui/gl/gl_surface_ozone.cc
@@ -15,7 +15,7 @@
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
-#include "ui/gl/gl_image_linux_dma_buffer.h"
+#include "ui/gl/gl_image_ozone_native_pixmap.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_osmesa.h"
@@ -36,7 +36,7 @@ void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
                        EGL_FOREVER_KHR);
 }
 
-// A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow
+// A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow.
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
   GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
@@ -71,8 +71,7 @@ GLSurfaceOzoneEGL::GLSurfaceOzoneEGL(
     AcceleratedWidget widget)
     : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()),
       ozone_surface_(ozone_surface.Pass()),
-      widget_(widget) {
-}
+      widget_(widget) {}
 
 bool GLSurfaceOzoneEGL::Initialize() {
   return Initialize(ozone_surface_->CreateVSyncProvider());
@@ -107,7 +106,7 @@ bool GLSurfaceOzoneEGL::ScheduleOverlayPlane(int z_order,
 }
 
 GLSurfaceOzoneEGL::~GLSurfaceOzoneEGL() {
-  Destroy();  // EGL surface must be destroyed before SurfaceOzone
+  Destroy();  // The EGL surface must be destroyed before SurfaceOzone.
 }
 
 bool GLSurfaceOzoneEGL::ReinitializeNativeSurface() {
@@ -121,8 +120,7 @@ bool GLSurfaceOzoneEGL::ReinitializeNativeSurface() {
   Destroy();
   ozone_surface_ = ui::OzonePlatform::GetInstance()
                        ->GetSurfaceFactoryOzone()
-                       ->CreateEGLSurfaceForWidget(widget_)
-                       .Pass();
+                       ->CreateEGLSurfaceForWidget(widget_);
   if (!ozone_surface_) {
     LOG(ERROR) << "Failed to create native surface.";
     return false;
@@ -222,8 +220,7 @@ GLSurfaceOzoneSurfaceless::Overlay::Overlay(int z_order,
       transform(transform),
       image(image),
       bounds_rect(bounds_rect),
-      crop_rect(crop_rect) {
-}
+      crop_rect(crop_rect) {}
 
 bool GLSurfaceOzoneSurfaceless::Overlay::ScheduleOverlayPlane(
     gfx::AcceleratedWidget widget) const {
@@ -231,8 +228,7 @@ bool GLSurfaceOzoneSurfaceless::Overlay::ScheduleOverlayPlane(
                                      crop_rect);
 }
 
-GLSurfaceOzoneSurfaceless::PendingFrame::PendingFrame() : ready(false) {
-}
+GLSurfaceOzoneSurfaceless::PendingFrame::PendingFrame() : ready(false) {}
 
 bool GLSurfaceOzoneSurfaceless::PendingFrame::ScheduleOverlayPlanes(
     gfx::AcceleratedWidget widget) {
@@ -264,12 +260,14 @@ bool GLSurfaceOzoneSurfaceless::Initialize() {
     return false;
   return true;
 }
+
 bool GLSurfaceOzoneSurfaceless::Resize(const gfx::Size& size) {
   if (!ozone_surface_->ResizeNativeWindow(size))
     return false;
 
   return SurfacelessEGL::Resize(size);
 }
+
 gfx::SwapResult GLSurfaceOzoneSurfaceless::SwapBuffers() {
   glFlush();
   // TODO: the following should be replaced by a per surface flush as it gets
@@ -292,6 +290,7 @@ gfx::SwapResult GLSurfaceOzoneSurfaceless::SwapBuffers() {
   return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
                                          : gfx::SwapResult::SWAP_FAILED;
 }
+
 bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(int z_order,
                                                      OverlayTransform transform,
                                                      GLImage* image,
@@ -301,15 +300,19 @@ bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(int z_order,
       Overlay(z_order, transform, image, bounds_rect, crop_rect));
   return true;
 }
+
 bool GLSurfaceOzoneSurfaceless::IsOffscreen() {
   return false;
 }
+
 VSyncProvider* GLSurfaceOzoneSurfaceless::GetVSyncProvider() {
   return vsync_provider_.get();
 }
+
 bool GLSurfaceOzoneSurfaceless::SupportsPostSubBuffer() {
   return true;
 }
+
 gfx::SwapResult GLSurfaceOzoneSurfaceless::PostSubBuffer(int x,
                                                          int y,
                                                          int width,
@@ -318,6 +321,7 @@ gfx::SwapResult GLSurfaceOzoneSurfaceless::PostSubBuffer(int x,
   SwapBuffers();
   return gfx::SwapResult::SWAP_ACK;
 }
+
 bool GLSurfaceOzoneSurfaceless::SwapBuffersAsync(
     const SwapCompletionCallback& callback) {
   // If last swap failed, don't try to schedule new ones.
@@ -359,6 +363,7 @@ bool GLSurfaceOzoneSurfaceless::SwapBuffersAsync(
   SubmitFrame();
   return last_swap_buffers_result_;
 }
+
 bool GLSurfaceOzoneSurfaceless::PostSubBufferAsync(
     int x,
     int y,
@@ -369,7 +374,7 @@ bool GLSurfaceOzoneSurfaceless::PostSubBufferAsync(
 }
 
 GLSurfaceOzoneSurfaceless::~GLSurfaceOzoneSurfaceless() {
-  Destroy();  // EGL surface must be destroyed before SurfaceOzone
+  Destroy();  // The EGL surface must be destroyed before SurfaceOzone.
 }
 
 void GLSurfaceOzoneSurfaceless::SubmitFrame() {
@@ -426,31 +431,15 @@ class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl
   gfx::SwapResult SwapBuffers() override;
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   void Destroy() override;
+  bool IsSurfaceless() const override;
 
  private:
-  class SurfaceImage : public GLImageLinuxDMABuffer {
-   public:
-    SurfaceImage(const gfx::Size& size, unsigned internalformat);
-
-    bool Initialize(scoped_refptr<ui::NativePixmap> pixmap,
-                    gfx::GpuMemoryBuffer::Format format);
-    bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                              int z_order,
-                              gfx::OverlayTransform transform,
-                              const gfx::Rect& bounds_rect,
-                              const gfx::RectF& crop_rect) override;
-
-   private:
-    ~SurfaceImage() override;
-
-    scoped_refptr<ui::NativePixmap> pixmap_;
-  };
-
   ~GLSurfaceOzoneSurfacelessSurfaceImpl() override;
 
   void BindFramebuffer();
   bool CreatePixmaps();
 
+  scoped_refptr<GLContext> context_;
   GLuint fbo_;
   GLuint textures_[2];
   scoped_refptr<GLImage> images_[2];
@@ -458,39 +447,11 @@ class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfacelessSurfaceImpl);
 };
 
-GLSurfaceOzoneSurfacelessSurfaceImpl::SurfaceImage::SurfaceImage(
-    const gfx::Size& size,
-    unsigned internalformat)
-    : GLImageLinuxDMABuffer(size, internalformat) {
-}
-
-bool GLSurfaceOzoneSurfacelessSurfaceImpl::SurfaceImage::Initialize(
-    scoped_refptr<ui::NativePixmap> pixmap,
-    gfx::GpuMemoryBuffer::Format format) {
-  base::FileDescriptor handle(pixmap->GetDmaBufFd(), false);
-  if (!GLImageLinuxDMABuffer::Initialize(handle, format,
-                                         pixmap->GetDmaBufPitch()))
-    return false;
-  pixmap_ = pixmap;
-  return true;
-}
-bool GLSurfaceOzoneSurfacelessSurfaceImpl::SurfaceImage::ScheduleOverlayPlane(
-    gfx::AcceleratedWidget widget,
-    int z_order,
-    gfx::OverlayTransform transform,
-    const gfx::Rect& bounds_rect,
-    const gfx::RectF& crop_rect) {
-  return pixmap_->ScheduleOverlayPlane(widget, z_order, transform, bounds_rect,
-                                       crop_rect);
-}
-
-GLSurfaceOzoneSurfacelessSurfaceImpl::SurfaceImage::~SurfaceImage() {
-}
-
 GLSurfaceOzoneSurfacelessSurfaceImpl::GLSurfaceOzoneSurfacelessSurfaceImpl(
     scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     AcceleratedWidget widget)
     : GLSurfaceOzoneSurfaceless(ozone_surface.Pass(), widget),
+      context_(nullptr),
       fbo_(0),
       current_surface_(0) {
   for (auto& texture : textures_)
@@ -503,6 +464,8 @@ GLSurfaceOzoneSurfacelessSurfaceImpl::GetBackingFrameBufferObject() {
 }
 
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::OnMakeCurrent(GLContext* context) {
+  DCHECK(!context_ || context == context_);
+  context_ = context;
   if (!fbo_) {
     glGenFramebuffersEXT(1, &fbo_);
     if (!fbo_)
@@ -553,8 +516,9 @@ bool GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffersAsync(
 }
 
 void GLSurfaceOzoneSurfacelessSurfaceImpl::Destroy() {
-  GLContext* current_context = GLContext::GetCurrent();
-  DCHECK(current_context && current_context->IsCurrent(this));
+  if (!context_)
+    return;
+  ui::ScopedMakeCurrent context(context_.get(), this);
   glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
   if (fbo_) {
     glDeleteTextures(arraysize(textures_), textures_);
@@ -569,6 +533,10 @@ void GLSurfaceOzoneSurfacelessSurfaceImpl::Destroy() {
   }
 }
 
+bool GLSurfaceOzoneSurfacelessSurfaceImpl::IsSurfaceless() const {
+  return false;
+}
+
 GLSurfaceOzoneSurfacelessSurfaceImpl::~GLSurfaceOzoneSurfacelessSurfaceImpl() {
   DCHECK(!fbo_);
   for (size_t i = 0; i < arraysize(textures_); i++)
@@ -589,13 +557,13 @@ bool GLSurfaceOzoneSurfacelessSurfaceImpl::CreatePixmaps() {
         ui::OzonePlatform::GetInstance()
             ->GetSurfaceFactoryOzone()
             ->CreateNativePixmap(widget_, GetSize(),
-                                 ui::SurfaceFactoryOzone::BGRA_8888,
-                                 ui::SurfaceFactoryOzone::SCANOUT);
+                                 gfx::BufferFormat::BGRA_8888,
+                                 gfx::BufferUsage::SCANOUT);
     if (!pixmap)
       return false;
-    scoped_refptr<SurfaceImage> image =
-        new SurfaceImage(GetSize(), GL_BGRA_EXT);
-    if (!image->Initialize(pixmap, gfx::GpuMemoryBuffer::Format::BGRA_8888))
+    scoped_refptr<GLImageOzoneNativePixmap> image =
+        new GLImageOzoneNativePixmap(GetSize(), GL_BGRA_EXT);
+    if (!image->Initialize(pixmap.get(), gfx::BufferFormat::BGRA_8888))
       return false;
     images_[i] = image;
     // Bind image to texture.
@@ -606,6 +574,36 @@ bool GLSurfaceOzoneSurfacelessSurfaceImpl::CreatePixmaps() {
   return true;
 }
 
+scoped_refptr<GLSurface> CreateViewGLSurfaceOzone(
+    gfx::AcceleratedWidget window) {
+  scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
+      ui::OzonePlatform::GetInstance()
+          ->GetSurfaceFactoryOzone()
+          ->CreateEGLSurfaceForWidget(window);
+  if (!surface_ozone)
+    return nullptr;
+  scoped_refptr<GLSurface> surface =
+      new GLSurfaceOzoneEGL(surface_ozone.Pass(), window);
+  if (!surface->Initialize())
+    return nullptr;
+  return surface;
+}
+
+scoped_refptr<GLSurface> CreateViewGLSurfaceOzoneSurfacelessSurfaceImpl(
+    gfx::AcceleratedWidget window) {
+  scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
+      ui::OzonePlatform::GetInstance()
+          ->GetSurfaceFactoryOzone()
+          ->CreateSurfacelessEGLSurfaceForWidget(window);
+  if (!surface_ozone)
+    return nullptr;
+  scoped_refptr<GLSurface> surface =
+      new GLSurfaceOzoneSurfacelessSurfaceImpl(surface_ozone.Pass(), window);
+  if (!surface->Initialize())
+    return nullptr;
+  return surface;
+}
+
 }  // namespace
 
 // static
@@ -631,10 +629,7 @@ scoped_refptr<GLSurface> GLSurface::CreateSurfacelessViewGLSurface(
     gfx::AcceleratedWidget window) {
   if (GetGLImplementation() == kGLImplementationEGLGLES2 &&
       window != kNullAcceleratedWidget &&
-      GLSurfaceEGL::IsEGLSurfacelessContextSupported() &&
-      ui::OzonePlatform::GetInstance()
-          ->GetSurfaceFactoryOzone()
-          ->CanShowPrimaryPlaneAsOverlay()) {
+      GLSurfaceEGL::IsEGLSurfacelessContextSupported()) {
     scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
         ui::OzonePlatform::GetInstance()
             ->GetSurfaceFactoryOzone()
@@ -656,43 +651,23 @@ scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
   if (GetGLImplementation() == kGLImplementationOSMesaGL) {
     scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless());
     if (!surface->Initialize())
-      return NULL;
+      return nullptr;
     return surface;
   }
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
   if (window != kNullAcceleratedWidget) {
     scoped_refptr<GLSurface> surface;
-    if (GLSurfaceEGL::IsEGLSurfacelessContextSupported() &&
-        ui::OzonePlatform::GetInstance()
-            ->GetSurfaceFactoryOzone()
-            ->CanShowPrimaryPlaneAsOverlay()) {
-      scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
-          ui::OzonePlatform::GetInstance()
-              ->GetSurfaceFactoryOzone()
-              ->CreateSurfacelessEGLSurfaceForWidget(window);
-      if (!surface_ozone)
-        return NULL;
-      surface = new GLSurfaceOzoneSurfacelessSurfaceImpl(surface_ozone.Pass(),
-                                                         window);
-    } else {
-      scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
-          ui::OzonePlatform::GetInstance()
-              ->GetSurfaceFactoryOzone()
-              ->CreateEGLSurfaceForWidget(window);
-      if (!surface_ozone)
-        return NULL;
-
-      surface = new GLSurfaceOzoneEGL(surface_ozone.Pass(), window);
-    }
-    if (!surface->Initialize())
-      return NULL;
+    if (GLSurfaceEGL::IsEGLSurfacelessContextSupported())
+      surface = CreateViewGLSurfaceOzoneSurfacelessSurfaceImpl(window);
+    if (!surface)
+      surface = CreateViewGLSurfaceOzone(window);
     return surface;
   } else {
     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
     if (surface->Initialize())
       return surface;
   }
-  return NULL;
+  return nullptr;
 }
 
 // static
@@ -703,7 +678,7 @@ scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface(
       scoped_refptr<GLSurface> surface(
           new GLSurfaceOSMesa(OSMesaSurfaceFormatBGRA, size));
       if (!surface->Initialize())
-        return NULL;
+        return nullptr;
 
       return surface;
     }
@@ -716,14 +691,14 @@ scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface(
         surface = new PbufferGLSurfaceEGL(size);
 
       if (!surface->Initialize())
-        return NULL;
+        return nullptr;
       return surface;
     }
     case kGLImplementationMockGL:
       return new GLSurfaceStub;
     default:
       NOTREACHED();
-      return NULL;
+      return nullptr;
   }
 }
 
diff --git a/chromium/ui/gl/gl_surface_win.cc b/chromium/ui/gl/gl_surface_win.cc
index c416e6b21ce..93410cae6ae 100644
--- a/chromium/ui/gl/gl_surface_win.cc
+++ b/chromium/ui/gl/gl_surface_win.cc
@@ -171,6 +171,13 @@ bool GLSurface::InitializeOneOffInternal() {
         return false;
       }
       break;
+    case kGLImplementationNone:
+    case kGLImplementationDesktopGLCoreProfile:
+    case kGLImplementationAppleGL:
+      NOTREACHED();
+    case kGLImplementationOSMesaGL:
+    case kGLImplementationMockGL:
+      break;
   }
   return true;
 }
diff --git a/chromium/ui/gl/gl_switches.cc b/chromium/ui/gl/gl_switches.cc
index 4ac132843d4..dc217ef9405 100644
--- a/chromium/ui/gl/gl_switches.cc
+++ b/chromium/ui/gl/gl_switches.cc
@@ -29,6 +29,10 @@ namespace switches {
 const char kDisableD3D11[]                  = "disable-d3d11";
 
 // Stop the GPU from synchronizing on the vsync before presenting.
+// We can select from the options below:
+//  beginframe : Next frame can start without any delay on cc::scheduler.
+//  gpu : Disable gpu vsync.
+//  default: Set both flags.
 const char kDisableGpuVsync[]               = "disable-gpu-vsync";
 
 // Turns on GPU logging (debug build only).
diff --git a/chromium/ui/gl/gl_tests.gyp b/chromium/ui/gl/gl_tests.gyp
index 37dec4fb207..4f7e2dd8656 100644
--- a/chromium/ui/gl/gl_tests.gyp
+++ b/chromium/ui/gl/gl_tests.gyp
@@ -24,6 +24,7 @@
         '<(DEPTH)/testing/gmock.gyp:gmock',
         '<(DEPTH)/testing/gtest.gyp:gtest',
         '<(DEPTH)/ui/gl/gl.gyp:gl',
+        '<(DEPTH)/ui/gl/gl.gyp:gl_test_support',
         '<(DEPTH)/ui/gl/gl.gyp:gl_unittest_utils',
       ],
       'conditions': [
diff --git a/chromium/ui/gl/gl_unittests.isolate b/chromium/ui/gl/gl_unittests.isolate
index e8b1d41f4bd..9c8a2dcbc8f 100644
--- a/chromium/ui/gl/gl_unittests.isolate
+++ b/chromium/ui/gl/gl_unittests.isolate
@@ -8,9 +8,6 @@
         'command': [
           '<(PRODUCT_DIR)/gl_unittests<(EXECUTABLE_SUFFIX)',
         ],
-        'files': [
-          '<(PRODUCT_DIR)/gl_unittests<(EXECUTABLE_SUFFIX)',
-        ],
       },
     }],
   ],
diff --git a/chromium/ui/gl/gl_version_info.cc b/chromium/ui/gl/gl_version_info.cc
index 5eff43a1cc6..cc960b0a3a8 100644
--- a/chromium/ui/gl/gl_version_info.cc
+++ b/chromium/ui/gl/gl_version_info.cc
@@ -50,7 +50,8 @@ GLVersionInfo::GLVersionInfo(const char* version_str, const char* renderer_str)
                        &is_es, &is_es3);
   }
   if (renderer_str) {
-    is_angle = base::StartsWithASCII(renderer_str, "ANGLE", true);
+    is_angle = base::StartsWith(renderer_str, "ANGLE",
+                                base::CompareCase::SENSITIVE);
   }
 }
 
@@ -66,7 +67,7 @@ void GLVersionInfo::ParseVersionString(const char* version_str,
   *is_es3 = false;
   if (!version_str)
     return;
-  std::string lstr(base::StringToLowerASCII(std::string(version_str)));
+  std::string lstr(base::ToLowerASCII(version_str));
   *is_es = (lstr.length() > 12) && (lstr.substr(0, 9) == "opengl es");
   if (*is_es)
     lstr = lstr.substr(10, 3);
diff --git a/chromium/ui/gl/gpu_switching_manager.cc b/chromium/ui/gl/gpu_switching_manager.cc
index 36ad7adde2a..a178509dc6b 100644
--- a/chromium/ui/gl/gpu_switching_manager.cc
+++ b/chromium/ui/gl/gpu_switching_manager.cc
@@ -24,7 +24,7 @@ struct GpuSwitchingManager::PlatformSpecific {
 
 // static
 GpuSwitchingManager* GpuSwitchingManager::GetInstance() {
-  return Singleton<GpuSwitchingManager>::get();
+  return base::Singleton<GpuSwitchingManager>::get();
 }
 
 GpuSwitchingManager::GpuSwitchingManager()
diff --git a/chromium/ui/gl/gpu_switching_manager.h b/chromium/ui/gl/gpu_switching_manager.h
index ba60945ea28..6327798132b 100644
--- a/chromium/ui/gl/gpu_switching_manager.h
+++ b/chromium/ui/gl/gpu_switching_manager.h
@@ -51,7 +51,7 @@ class GL_EXPORT GpuSwitchingManager {
   void NotifyGpuSwitched();
 
  private:
-  friend struct DefaultSingletonTraits<GpuSwitchingManager>;
+  friend struct base::DefaultSingletonTraits<GpuSwitchingManager>;
 
   GpuSwitchingManager();
   virtual ~GpuSwitchingManager();
diff --git a/chromium/ui/gl/gpu_timing.cc b/chromium/ui/gl/gpu_timing.cc
index c90225434d6..e78442e44ab 100644
--- a/chromium/ui/gl/gpu_timing.cc
+++ b/chromium/ui/gl/gpu_timing.cc
@@ -11,6 +11,9 @@
 
 namespace gfx {
 
+class TimeElapsedTimerQuery;
+class TimerQuery;
+
 int64_t NanoToMicro(uint64_t nano_seconds) {
   const uint64_t up = nano_seconds + base::Time::kNanosecondsPerMicrosecond / 2;
   return static_cast<int64_t>(up / base::Time::kNanosecondsPerMicrosecond);
@@ -313,6 +316,7 @@ GPUTimingImpl::GPUTimingImpl(GLContextReal* context) {
     timer_type_ = GPUTiming::kTimerTypeARB;
   } else if (context->HasExtension("GL_EXT_timer_query")) {
     timer_type_ = GPUTiming::kTimerTypeEXT;
+    force_time_elapsed_query_ = true;
   }
 }
 
@@ -375,8 +379,7 @@ void GPUTimingImpl::EndElapsedTimeQuery(scoped_refptr<QueryResult> result) {
 }
 
 scoped_refptr<QueryResult> GPUTimingImpl::DoTimeStampQuery() {
-  DCHECK(timer_type_ == GPUTiming::kTimerTypeDisjoint ||
-         timer_type_ == GPUTiming::kTimerTypeARB);
+  DCHECK(timer_type_ != GPUTiming::kTimerTypeInvalid);
 
   if (force_time_elapsed_query_) {
     // Replace with elapsed timer queries instead.
@@ -467,7 +470,7 @@ GPUTimer::~GPUTimer() {
 
 void GPUTimer::Destroy(bool have_context) {
   if (have_context) {
-    if (!end_requested_) {
+    if (timer_state_ == kTimerState_WaitingForEnd) {
       DCHECK(gpu_timing_client_->gpu_timing_);
       DCHECK(elapsed_timer_result_.get());
       gpu_timing_client_->gpu_timing_->EndElapsedTimeQuery(
@@ -476,56 +479,81 @@ void GPUTimer::Destroy(bool have_context) {
   }
 }
 
+void GPUTimer::Reset() {
+  // We can reset from any state other than when a Start() is waiting for End().
+  DCHECK(timer_state_ != kTimerState_WaitingForEnd);
+  time_stamp_result_ = nullptr;
+  elapsed_timer_result_ = nullptr;
+  timer_state_ = kTimerState_Ready;
+}
+
+void GPUTimer::QueryTimeStamp() {
+  DCHECK(gpu_timing_client_->gpu_timing_);
+  Reset();
+  time_stamp_result_ = gpu_timing_client_->gpu_timing_->DoTimeStampQuery();
+  timer_state_ = kTimerState_WaitingForResult;
+}
+
 void GPUTimer::Start() {
   DCHECK(gpu_timing_client_->gpu_timing_);
+  Reset();
   if (!use_elapsed_timer_)
     time_stamp_result_ = gpu_timing_client_->gpu_timing_->DoTimeStampQuery();
 
   elapsed_timer_result_ =
       gpu_timing_client_->gpu_timing_->BeginElapsedTimeQuery();
+  timer_state_ = kTimerState_WaitingForEnd;
 }
 
 void GPUTimer::End() {
+  DCHECK(timer_state_ == kTimerState_WaitingForEnd);
   DCHECK(elapsed_timer_result_.get());
-  end_requested_ = true;
   gpu_timing_client_->gpu_timing_->EndElapsedTimeQuery(elapsed_timer_result_);
+  timer_state_ = kTimerState_WaitingForResult;
 }
 
 bool GPUTimer::IsAvailable() {
-  if (!end_requested_)
-    return false;
-  if (!end_available_) {
-    DCHECK(elapsed_timer_result_.get());
-    if (elapsed_timer_result_->IsAvailable()) {
-      end_available_ = true;
+  if (timer_state_ == kTimerState_WaitingForResult) {
+    // Elapsed timer are only used during start/end queries and always after
+    // the timestamp query. Otherwise only the timestamp is used.
+    scoped_refptr<QueryResult> result =
+        elapsed_timer_result_.get() ?
+        elapsed_timer_result_ :
+        time_stamp_result_;
+
+    DCHECK(result.get());
+    if (result->IsAvailable()) {
+      timer_state_ = kTimerState_ResultAvailable;
     } else {
       gpu_timing_client_->gpu_timing_->UpdateQueryResults();
-      end_available_ = elapsed_timer_result_->IsAvailable();
+      if (result->IsAvailable())
+        timer_state_ = kTimerState_ResultAvailable;
     }
   }
-  return end_available_;
+
+  return (timer_state_ == kTimerState_ResultAvailable);
 }
 
 void GPUTimer::GetStartEndTimestamps(int64* start, int64* end) {
   DCHECK(start && end);
-  DCHECK(elapsed_timer_result_.get());
+  DCHECK(elapsed_timer_result_.get() || time_stamp_result_.get());
   DCHECK(IsAvailable());
-  if (time_stamp_result_.get()) {
-    DCHECK(time_stamp_result_->IsAvailable());
-    const int64_t time_stamp = time_stamp_result_->GetStartValue();
-    *start = time_stamp;
-    *end = time_stamp + elapsed_timer_result_->GetDelta();
-  } else {
-    // Use estimation from elasped timer results.
-    *start = elapsed_timer_result_->GetStartValue();
-    *end = elapsed_timer_result_->GetEndValue();
-  }
+  const int64_t time_stamp = time_stamp_result_.get() ?
+                             time_stamp_result_->GetStartValue() :
+                             elapsed_timer_result_->GetStartValue();
+  const int64_t elapsed_time = elapsed_timer_result_.get() ?
+                               elapsed_timer_result_->GetDelta() :
+                               0;
+
+  *start = time_stamp;
+  *end = time_stamp + elapsed_time;
 }
 
 int64 GPUTimer::GetDeltaElapsed() {
-  DCHECK(elapsed_timer_result_.get());
   DCHECK(IsAvailable());
-  return elapsed_timer_result_->GetDelta();
+  if (elapsed_timer_result_.get())
+    return elapsed_timer_result_->GetDelta();
+  return 0;
 }
 
 GPUTimer::GPUTimer(scoped_refptr<GPUTimingClient> gpu_timing_client,
diff --git a/chromium/ui/gl/gpu_timing.h b/chromium/ui/gl/gpu_timing.h
index 08f9c0377d4..5d72d7cadea 100644
--- a/chromium/ui/gl/gpu_timing.h
+++ b/chromium/ui/gl/gpu_timing.h
@@ -43,12 +43,9 @@
 namespace gfx {
 
 class GLContextReal;
-class GPUTiming;
 class GPUTimingClient;
 class GPUTimingImpl;
 class QueryResult;
-class TimeElapsedTimerQuery;
-class TimerQuery;
 
 class GPUTiming {
  public:
@@ -86,6 +83,12 @@ class GL_EXPORT GPUTimer {
   // this object.
   void Destroy(bool have_context);
 
+  // Clears current queries.
+  void Reset();
+
+  // Start an instant timer, start and end will be equal.
+  void QueryTimeStamp();
+
   // Start a timer range.
   void Start();
   void End();
@@ -102,8 +105,12 @@ class GL_EXPORT GPUTimer {
                     bool use_elapsed_timer);
 
   bool use_elapsed_timer_ = false;
-  bool end_requested_ = false;
-  bool end_available_ = false;
+  enum TimerState {
+    kTimerState_Ready,
+    kTimerState_WaitingForEnd,
+    kTimerState_WaitingForResult,
+    kTimerState_ResultAvailable
+  } timer_state_ = kTimerState_Ready;
   scoped_refptr<GPUTimingClient> gpu_timing_client_;
   scoped_refptr<QueryResult> time_stamp_result_;
   scoped_refptr<QueryResult> elapsed_timer_result_;
diff --git a/chromium/ui/gl/gpu_timing_fake.cc b/chromium/ui/gl/gpu_timing_fake.cc
index e7c1df99d06..03f4af3d6ea 100644
--- a/chromium/ui/gl/gpu_timing_fake.cc
+++ b/chromium/ui/gl/gpu_timing_fake.cc
@@ -4,6 +4,7 @@
 
 #include "ui/gl/gpu_timing_fake.h"
 
+#include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
@@ -16,6 +17,8 @@ using ::testing::Exactly;
 using ::testing::Invoke;
 using ::testing::NotNull;
 
+int64_t GPUTimingFake::fake_cpu_time_ = 0;
+
 GPUTimingFake::GPUTimingFake() {
   Reset();
 }
@@ -24,15 +27,34 @@ GPUTimingFake::~GPUTimingFake() {
 }
 
 void GPUTimingFake::Reset() {
-  current_time_ = 0;
+  current_gl_time_ = 0;
+  gl_cpu_time_offset_ = 0;
   next_query_id_ = 23;
   allocated_queries_.clear();
   query_results_.clear();
   current_elapsed_query_.Reset();
+
+  fake_cpu_time_ = 0;
+}
+
+int64_t GPUTimingFake::GetFakeCPUTime() {
+  return fake_cpu_time_;
+}
+
+void GPUTimingFake::SetCPUGLOffset(int64_t offset) {
+  gl_cpu_time_offset_ = offset;
+}
+
+void GPUTimingFake::SetCurrentCPUTime(int64_t current_time) {
+  fake_cpu_time_ = current_time;
+  current_gl_time_ = (fake_cpu_time_ + gl_cpu_time_offset_) *
+                     base::Time::kNanosecondsPerMicrosecond;
 }
 
 void GPUTimingFake::SetCurrentGLTime(GLint64 current_time) {
-  current_time_ = current_time;
+  current_gl_time_ = current_time;
+  fake_cpu_time_ = (current_gl_time_ / base::Time::kNanosecondsPerMicrosecond) -
+                   gl_cpu_time_offset_;
 }
 
 void GPUTimingFake::SetDisjoint() {
@@ -53,9 +75,48 @@ void GPUTimingFake::ExpectNoDisjointCalls(MockGLInterface& gl) {
   EXPECT_CALL(gl, GetIntegerv(GL_GPU_DISJOINT_EXT, _)).Times(Exactly(0));
 }
 
+void GPUTimingFake::ExpectGPUTimeStampQuery(
+    MockGLInterface& gl, bool elapsed_query) {
+  EXPECT_CALL(gl, GenQueries(1, NotNull())).Times(Exactly(1))
+      .WillRepeatedly(Invoke(this, &GPUTimingFake::FakeGLGenQueries));
+
+  if (!elapsed_query) {
+    // Time Stamp based queries.
+    EXPECT_CALL(gl, GetInteger64v(GL_TIMESTAMP, _))
+        .WillRepeatedly(
+            Invoke(this, &GPUTimingFake::FakeGLGetInteger64v));
+
+    EXPECT_CALL(gl, QueryCounter(_, GL_TIMESTAMP)).Times(Exactly(1))
+        .WillRepeatedly(
+             Invoke(this, &GPUTimingFake::FakeGLQueryCounter));
+  } else {
+    // Time Elapsed based queries.
+    EXPECT_CALL(gl, BeginQuery(GL_TIME_ELAPSED, _)).Times(Exactly(1))
+        .WillRepeatedly(
+            Invoke(this, &GPUTimingFake::FakeGLBeginQuery));
+
+    EXPECT_CALL(gl, EndQuery(GL_TIME_ELAPSED)).Times(Exactly(1))
+      .WillRepeatedly(Invoke(this, &GPUTimingFake::FakeGLEndQuery));
+  }
+
+  EXPECT_CALL(gl, GetQueryObjectuiv(_, GL_QUERY_RESULT_AVAILABLE,
+                                    NotNull()))
+      .WillRepeatedly(
+          Invoke(this, &GPUTimingFake::FakeGLGetQueryObjectuiv));
+
+  EXPECT_CALL(gl, GetQueryObjectui64v(_, GL_QUERY_RESULT, NotNull()))
+      .WillRepeatedly(
+           Invoke(this, &GPUTimingFake::FakeGLGetQueryObjectui64v));
+
+  EXPECT_CALL(gl, DeleteQueries(1, NotNull())).Times(AtLeast(1))
+      .WillRepeatedly(
+           Invoke(this, &GPUTimingFake::FakeGLDeleteQueries));
+}
+
 void GPUTimingFake::ExpectGPUTimerQuery(
     MockGLInterface& gl, bool elapsed_query) {
-  EXPECT_CALL(gl, GenQueries(1, NotNull())).Times(AtLeast(2))
+  EXPECT_CALL(gl, GenQueries(1, NotNull()))
+      .Times(AtLeast(elapsed_query ? 1 : 2))
       .WillRepeatedly(Invoke(this, &GPUTimingFake::FakeGLGenQueries));
 
   if (!elapsed_query) {
@@ -86,7 +147,8 @@ void GPUTimingFake::ExpectGPUTimerQuery(
       .WillRepeatedly(
            Invoke(this, &GPUTimingFake::FakeGLGetQueryObjectui64v));
 
-  EXPECT_CALL(gl, DeleteQueries(1, NotNull())).Times(AtLeast(2))
+  EXPECT_CALL(gl, DeleteQueries(1, NotNull()))
+      .Times(AtLeast(elapsed_query ? 1 : 2))
       .WillRepeatedly(
            Invoke(this, &GPUTimingFake::FakeGLDeleteQueries));
 }
@@ -127,7 +189,7 @@ void GPUTimingFake::FakeGLBeginQuery(GLenum target, GLuint id) {
       current_elapsed_query_.Reset();
       current_elapsed_query_.active_ = true;
       current_elapsed_query_.query_id_ = id;
-      current_elapsed_query_.begin_time_ = current_time_;
+      current_elapsed_query_.begin_time_ = current_gl_time_;
       break;
     default:
       FAIL() << "Invalid target passed to BeginQuery: " << target;
@@ -141,7 +203,7 @@ void GPUTimingFake::FakeGLEndQuery(GLenum target) {
       QueryResult& query = query_results_[current_elapsed_query_.query_id_];
       query.type_ = QueryResult::kQueryResultType_Elapsed;
       query.begin_time_ = current_elapsed_query_.begin_time_;
-      query.value_ = current_time_;
+      query.value_ = current_gl_time_;
       current_elapsed_query_.active_ = false;
     } break;
     default:
@@ -154,7 +216,7 @@ void GPUTimingFake::FakeGLGetQueryObjectuiv(GLuint id, GLenum pname,
   switch (pname) {
     case GL_QUERY_RESULT_AVAILABLE: {
       std::map<GLuint, QueryResult>::iterator it = query_results_.find(id);
-      if (it != query_results_.end() && it->second.value_ <= current_time_)
+      if (it != query_results_.end() && it->second.value_ <= current_gl_time_)
         *params = 1;
       else
         *params = 0;
@@ -170,7 +232,7 @@ void GPUTimingFake::FakeGLQueryCounter(GLuint id, GLenum target) {
       ASSERT_TRUE(allocated_queries_.find(id) != allocated_queries_.end());
       QueryResult& query = query_results_[id];
       query.type_ = QueryResult::kQueryResultType_TimeStamp;
-      query.value_ = current_time_;
+      query.value_ = current_gl_time_;
     } break;
 
     default:
@@ -181,7 +243,7 @@ void GPUTimingFake::FakeGLQueryCounter(GLuint id, GLenum target) {
 void GPUTimingFake::FakeGLGetInteger64v(GLenum pname, GLint64 * data) {
   switch (pname) {
     case GL_TIMESTAMP:
-      *data = current_time_;
+      *data = current_gl_time_;
       break;
     default:
       FAIL() << "Invalid variable passed to GetInteger64v: " << pname;
diff --git a/chromium/ui/gl/gpu_timing_fake.h b/chromium/ui/gl/gpu_timing_fake.h
index 40c93f42576..33d7bc3d817 100644
--- a/chromium/ui/gl/gpu_timing_fake.h
+++ b/chromium/ui/gl/gpu_timing_fake.h
@@ -21,7 +21,10 @@ class GPUTimingFake {
   void Reset();
 
   // Used to set the current GPU time queries will return.
+  static int64_t GetFakeCPUTime(); // Useful for binding for Fake CPU time.
+  void SetCurrentCPUTime(int64_t current_time);
   void SetCurrentGLTime(GLint64 current_time);
+  void SetCPUGLOffset(int64_t offset);
 
   // Used to signal a disjoint occurred for disjoint timer queries.
   void SetDisjoint();
@@ -32,6 +35,7 @@ class GPUTimingFake {
   void ExpectNoDisjointCalls(MockGLInterface& gl);
 
   // GPUTimer fake queries which can only be called once per setup.
+  void ExpectGPUTimeStampQuery(MockGLInterface& gl, bool elapsed_query);
   void ExpectGPUTimerQuery(MockGLInterface& gl, bool elapsed_query);
   void ExpectOffsetCalculationQuery(MockGLInterface& gl);
   void ExpectNoOffsetCalculationQuery(MockGLInterface& gl);
@@ -50,7 +54,9 @@ class GPUTimingFake {
 
  protected:
   bool disjointed_ = false;
-  GLint64 current_time_ = 0;
+  static int64_t fake_cpu_time_;
+  GLint64 current_gl_time_ = 0;
+  int64_t gl_cpu_time_offset_ = 0;
   GLuint next_query_id_ = 0;
   std::set<GLuint> allocated_queries_;
   struct QueryResult {
diff --git a/chromium/ui/gl/gpu_timing_unittest.cc b/chromium/ui/gl/gpu_timing_unittest.cc
index 9044394d697..865eb24b049 100644
--- a/chromium/ui/gl/gpu_timing_unittest.cc
+++ b/chromium/ui/gl/gpu_timing_unittest.cc
@@ -8,9 +8,10 @@
 #include "ui/gl/gl_context_stub_with_extensions.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_mock.h"
-#include "ui/gl/gl_surface.h"
 #include "ui/gl/gpu_preference.h"
 #include "ui/gl/gpu_timing.h"
+#include "ui/gl/gpu_timing_fake.h"
+#include "ui/gl/test/gl_surface_test_support.h"
 
 namespace gfx {
 
@@ -18,25 +19,33 @@ class GPUTimingTest : public testing::Test {
  public:
   void SetUp() override {
     setup_ = false;
-    fake_cpu_time_ = 0;
-
-    CreateGPUTimingClient()->SetCpuTimeForTesting(base::Bind(&GetFakeCPUTime));
+    cpu_time_bounded_ = false;
   }
 
   void TearDown() override {
+    if (setup_) {
+      MockGLInterface::SetGLInterface(NULL);
+      gfx::ClearGLBindings();
+    }
+    setup_ = false;
+    cpu_time_bounded_ = false;
     context_ = nullptr;
+    gl_.reset();
+    gpu_timing_fake_queries_.Reset();
   }
 
   void SetupGLContext(const char* gl_version, const char* gl_extensions) {
     ASSERT_FALSE(setup_) << "Cannot setup GL context twice.";
-    gfx::SetGLGetProcAddressProc(gfx::MockGLInterface::GetGLProcAddress);
-    gfx::GLSurface::InitializeOneOffWithMockBindingsForTests();
-    gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
-    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+    SetGLGetProcAddressProc(MockGLInterface::GetGLProcAddress);
+    GLSurfaceTestSupport::InitializeOneOffWithMockBindings();
+    gl_.reset(new ::testing::StrictMock<MockGLInterface>());
+    MockGLInterface::SetGLInterface(gl_.get());
 
-    context_ = new gfx::GLContextStubWithExtensions;
+    context_ = new GLContextStubWithExtensions;
     context_->AddExtensionsString(gl_extensions);
     context_->SetGLVersionString(gl_version);
+    gpu_timing_fake_queries_.Reset();
+    GLSurfaceTestSupport::InitializeDynamicMockBindings(context_.get());
 
     setup_ = true;
   }
@@ -45,33 +54,28 @@ class GPUTimingTest : public testing::Test {
     if (!setup_) {
       SetupGLContext("2.0", "");
     }
-    return context_->CreateGPUTimingClient();
-  }
 
-  void SetFakeCPUTime(int64_t fake_cpu_time) {
-    fake_cpu_time_ = fake_cpu_time;
+    scoped_refptr<GPUTimingClient> client = context_->CreateGPUTimingClient();
+    if (!cpu_time_bounded_) {
+      client->SetCpuTimeForTesting(base::Bind(&GPUTimingFake::GetFakeCPUTime));
+      cpu_time_bounded_ = true;
+    }
+    return client;
   }
 
  protected:
-  static int64_t GetFakeCPUTime() {
-    return fake_cpu_time_;
-  }
-
- private:
-  static int64_t fake_cpu_time_;
-
   bool setup_ = false;
-  scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
-  scoped_refptr<gfx::GLContextStubWithExtensions> context_;
+  bool cpu_time_bounded_ = false;
+  scoped_ptr< ::testing::StrictMock<MockGLInterface> > gl_;
+  scoped_refptr<GLContextStubWithExtensions> context_;
+  GPUTimingFake gpu_timing_fake_queries_;
 };
 
-int64_t GPUTimingTest::fake_cpu_time_ = 0;
-
 TEST_F(GPUTimingTest, FakeTimerTest) {
-  // Tests that we can properly set fake cpu times.
-  SetFakeCPUTime(123);
-
   scoped_refptr<GPUTimingClient> gpu_timing_client = CreateGPUTimingClient();
+
+  // Tests that we can properly set fake cpu times.
+  gpu_timing_fake_queries_.SetCurrentCPUTime(123);
   EXPECT_EQ(123, gpu_timing_client->GetCurrentCPUTime());
 
   base::Callback<int64_t(void)> empty;
@@ -95,4 +99,66 @@ TEST_F(GPUTimingTest, ForceTimeElapsedQuery) {
   EXPECT_TRUE(client2->IsForceTimeElapsedQuery());
 }
 
+TEST_F(GPUTimingTest, QueryTimeStampTest) {
+  SetupGLContext("3.2", "GL_ARB_timer_query");
+  scoped_refptr<GPUTimingClient> client = CreateGPUTimingClient();
+  scoped_ptr<GPUTimer> gpu_timer = client->CreateGPUTimer(false);
+
+  const int64_t begin_cpu_time = 123;
+  const int64_t begin_gl_time = 10 * base::Time::kNanosecondsPerMicrosecond;
+  const int64_t cpu_gl_offset =
+      begin_gl_time / base::Time::kNanosecondsPerMicrosecond - begin_cpu_time;
+  gpu_timing_fake_queries_.SetCPUGLOffset(cpu_gl_offset);
+  gpu_timing_fake_queries_.SetCurrentCPUTime(begin_cpu_time);
+  gpu_timing_fake_queries_.ExpectGPUTimeStampQuery(*gl_, false);
+
+  gpu_timer->QueryTimeStamp();
+
+  gpu_timing_fake_queries_.SetCurrentCPUTime(begin_cpu_time - 1);
+  EXPECT_FALSE(gpu_timer->IsAvailable());
+
+  gpu_timing_fake_queries_.SetCurrentCPUTime(begin_cpu_time);
+  EXPECT_TRUE(gpu_timer->IsAvailable());
+
+  gpu_timing_fake_queries_.SetCurrentCPUTime(begin_cpu_time + 1);
+  EXPECT_TRUE(gpu_timer->IsAvailable());
+
+  EXPECT_EQ(0, gpu_timer->GetDeltaElapsed());
+
+  int64 start, end;
+  gpu_timer->GetStartEndTimestamps(&start, &end);
+  EXPECT_EQ(begin_cpu_time, start);
+  EXPECT_EQ(begin_cpu_time, end);
+}
+
+TEST_F(GPUTimingTest, QueryTimeStampUsingElapsedTest) {
+  // Test timestamp queries using GL_EXT_timer_query which does not support
+  // timestamp queries. Internally we fall back to time elapsed queries.
+  SetupGLContext("3.2", "GL_EXT_timer_query");
+  scoped_refptr<GPUTimingClient> client = CreateGPUTimingClient();
+  scoped_ptr<GPUTimer> gpu_timer = client->CreateGPUTimer(false);
+  ASSERT_TRUE(client->IsForceTimeElapsedQuery());
+
+  const int64_t begin_cpu_time = 123;
+  const int64_t begin_gl_time = 10 * base::Time::kNanosecondsPerMicrosecond;
+  const int64_t cpu_gl_offset = begin_gl_time - begin_cpu_time;
+  gpu_timing_fake_queries_.SetCPUGLOffset(cpu_gl_offset);
+  gpu_timing_fake_queries_.SetCurrentCPUTime(begin_cpu_time);
+  gpu_timing_fake_queries_.ExpectGPUTimeStampQuery(*gl_, true);
+
+  gpu_timer->QueryTimeStamp();
+
+  gpu_timing_fake_queries_.SetCurrentCPUTime(begin_cpu_time - 1);
+  EXPECT_FALSE(gpu_timer->IsAvailable());
+
+  gpu_timing_fake_queries_.SetCurrentCPUTime(begin_cpu_time + 1);
+  EXPECT_TRUE(gpu_timer->IsAvailable());
+  EXPECT_EQ(0, gpu_timer->GetDeltaElapsed());
+
+  int64 start, end;
+  gpu_timer->GetStartEndTimestamps(&start, &end);
+  EXPECT_EQ(begin_cpu_time, start);
+  EXPECT_EQ(begin_cpu_time, end);
+}
+
 }  // namespace gpu
diff --git a/chromium/ui/gl/scoped_api.cc b/chromium/ui/gl/scoped_api.cc
new file mode 100644
index 00000000000..f43f692ac0f
--- /dev/null
+++ b/chromium/ui/gl/scoped_api.cc
@@ -0,0 +1,20 @@
+// 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 gfx {
+
+ScopedSetGLToRealGLApi::ScopedSetGLToRealGLApi()
+    : old_gl_api_(GetCurrentGLApi()) {
+  SetGLToRealGLApi();
+}
+
+ScopedSetGLToRealGLApi::~ScopedSetGLToRealGLApi() {
+  SetGLApi(old_gl_api_);
+}
+
+}  // namespace gfx
diff --git a/chromium/ui/gl/scoped_api.h b/chromium/ui/gl/scoped_api.h
new file mode 100644
index 00000000000..dd9af506d9d
--- /dev/null
+++ b/chromium/ui/gl/scoped_api.h
@@ -0,0 +1,28 @@
+// 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/basictypes.h"
+#include "ui/gl/gl_export.h"
+
+namespace gfx {
+
+class GLApi;
+
+class GL_EXPORT ScopedSetGLToRealGLApi {
+ public:
+  ScopedSetGLToRealGLApi();
+  ~ScopedSetGLToRealGLApi();
+
+ private:
+  GLApi* old_gl_api_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedSetGLToRealGLApi);
+};
+
+}  // namespace gfx
+
+#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 66d3734f58e..9fee3687dde 100644
--- a/chromium/ui/gl/sync_control_vsync_provider.cc
+++ b/chromium/ui/gl/sync_control_vsync_provider.cc
@@ -8,6 +8,7 @@
 
 #include "base/logging.h"
 #include "base/time/time.h"
+#include "base/trace_event/trace_event.h"
 
 #if defined(OS_LINUX)
 // These constants define a reasonable range for a calculated refresh interval.
@@ -35,6 +36,7 @@ SyncControlVSyncProvider::~SyncControlVSyncProvider() {}
 
 void SyncControlVSyncProvider::GetVSyncParameters(
     const UpdateVSyncCallback& callback) {
+  TRACE_EVENT0("gpu", "SyncControlVSyncProvider::GetVSyncParameters");
 #if defined(OS_LINUX)
   base::TimeTicks timebase;
 
diff --git a/chromium/ui/gl/trace_util.cc b/chromium/ui/gl/trace_util.cc
new file mode 100644
index 00000000000..825de2802bf
--- /dev/null
+++ b/chromium/ui/gl/trace_util.cc
@@ -0,0 +1,43 @@
+// Copyright (c) 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/trace_util.h"
+
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+base::trace_event::MemoryAllocatorDumpGuid GetGLTextureClientGUIDForTracing(
+    uint64_t share_group_guid,
+    uint32_t texture_id) {
+  return base::trace_event::MemoryAllocatorDumpGuid(
+      base::StringPrintf("gl-texture-client-x-process/%" PRIx64 "/%d",
+                         share_group_guid, texture_id));
+}
+
+base::trace_event::MemoryAllocatorDumpGuid GetGLTextureServiceGUIDForTracing(
+    uint64_t share_group_guid,
+    uint32_t texture_id) {
+  return base::trace_event::MemoryAllocatorDumpGuid(
+      base::StringPrintf("gl-texture-service-x-process/%" PRIx64 "/%d",
+                         share_group_guid, texture_id));
+}
+
+base::trace_event::MemoryAllocatorDumpGuid GetGLBufferGUIDForTracing(
+    uint64_t share_group_guid,
+    uint32_t buffer_id) {
+  return base::trace_event::MemoryAllocatorDumpGuid(base::StringPrintf(
+      "gl-buffer-x-process/%" PRIx64 "/%d", share_group_guid, buffer_id));
+}
+
+base::trace_event::MemoryAllocatorDumpGuid GetGLRenderbufferGUIDForTracing(
+    uint64_t share_group_guid,
+    uint32_t renderbuffer_id) {
+  return base::trace_event::MemoryAllocatorDumpGuid(
+      base::StringPrintf("gl-renderbuffer-x-process/%" PRIx64 "/%d",
+                         share_group_guid, renderbuffer_id));
+}
+
+}  // namespace ui
diff --git a/chromium/ui/gl/trace_util.h b/chromium/ui/gl/trace_util.h
new file mode 100644
index 00000000000..fa7ab191d39
--- /dev/null
+++ b/chromium/ui/gl/trace_util.h
@@ -0,0 +1,31 @@
+// Copyright (c) 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_TRACE_UTIL_H_
+#define UI_GL_TRACE_UTIL_H_
+
+#include "base/trace_event/memory_allocator_dump.h"
+#include "ui/gl/gl_export.h"
+
+namespace gfx {
+
+GL_EXPORT base::trace_event::MemoryAllocatorDumpGuid
+GetGLTextureClientGUIDForTracing(uint64_t share_group_guid,
+                                 uint32_t texture_client_id);
+
+GL_EXPORT base::trace_event::MemoryAllocatorDumpGuid
+GetGLRenderbufferGUIDForTracing(uint64_t share_group_guid,
+                                uint32_t renderbuffer_id);
+
+GL_EXPORT base::trace_event::MemoryAllocatorDumpGuid
+GetGLTextureServiceGUIDForTracing(uint64_t share_group_guid,
+                                  uint32_t texture_service_id);
+
+GL_EXPORT base::trace_event::MemoryAllocatorDumpGuid GetGLBufferGUIDForTracing(
+    uint64_t share_group_guid,
+    uint32_t buffer_id);
+
+}  // namespace ui
+
+#endif  // UI_GL_TRACE_UTIL_H_