Make GL bindings conditional

ui/gl/gl_bindings_autogen_egl.cc

 // 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.
 //
 // This file is auto-generated from
 // ui/gl/generate_bindings.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_egl_api_implementation.h"
 #include "ui/gl/gl_enums.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gfx {
 
 static bool g_debugBindingsInitialized;
 DriverEGL g_driver_egl;
 
+EGLint eglClientWaitSyncKHRNotBound(EGLDisplay dpy,
+                                    EGLSyncKHR sync,
+                                    EGLint flags,
+                                    EGLTimeKHR timeout) {
+  NOTREACHED();
+  return 0;
+}
+EGLImageKHR eglCreateImageKHRNotBound(EGLDisplay dpy,
+                                      EGLContext ctx,
+                                      EGLenum target,
+                                      EGLClientBuffer buffer,
+                                      const EGLint* attrib_list) {
+  NOTREACHED();
+  return 0;
+}
+EGLSyncKHR eglCreateSyncKHRNotBound(EGLDisplay dpy,
+                                    EGLenum type,
+                                    const EGLint* attrib_list) {
+  NOTREACHED();
+  return 0;
+}
+EGLBoolean eglDestroyImageKHRNotBound(EGLDisplay dpy, EGLImageKHR image) {
+  NOTREACHED();
+  return 0;
+}
+EGLBoolean eglDestroySyncKHRNotBound(EGLDisplay dpy, EGLSyncKHR sync) {
+  NOTREACHED();
+  return 0;
+}
+EGLDisplay eglGetPlatformDisplayEXTNotBound(EGLenum platform,
+                                            void* native_display,
+                                            const EGLint* attrib_list) {
+  NOTREACHED();
+  return 0;
+}
+EGLBoolean eglGetSyncAttribKHRNotBound(EGLDisplay dpy,
+                                       EGLSyncKHR sync,
+                                       EGLint attribute,
+                                       EGLint* value) {
+  NOTREACHED();
+  return 0;
+}
+EGLBoolean eglGetSyncValuesCHROMIUMNotBound(EGLDisplay dpy,
+                                            EGLSurface surface,
+                                            EGLuint64CHROMIUM* ust,
+                                            EGLuint64CHROMIUM* msc,
+                                            EGLuint64CHROMIUM* sbc) {
+  NOTREACHED();
+  return 0;
+}
+EGLBoolean eglPostSubBufferNVNotBound(EGLDisplay dpy,
+                                      EGLSurface surface,
+                                      EGLint x,
+                                      EGLint y,
+                                      EGLint width,
+                                      EGLint height) {
+  NOTREACHED();
+  return 0;
+}
+EGLBoolean eglQuerySurfacePointerANGLENotBound(EGLDisplay dpy,
+                                               EGLSurface surface,
+                                               EGLint attribute,
+                                               void** value) {
+  NOTREACHED();
+  return 0;
+}
+EGLint eglWaitSyncKHRNotBound(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
+  NOTREACHED();
+  return 0;
+}
+
 void DriverEGL::InitializeStaticBindings() {
   fn.eglBindAPIFn =
       reinterpret_cast<eglBindAPIProc>(GetGLProcAddress("eglBindAPI"));
   fn.eglBindTexImageFn = reinterpret_cast<eglBindTexImageProc>(
       GetGLProcAddress("eglBindTexImage"));
   fn.eglChooseConfigFn = reinterpret_cast<eglChooseConfigProc>(
       GetGLProcAddress("eglChooseConfig"));
-  fn.eglClientWaitSyncKHRFn = reinterpret_cast<eglClientWaitSyncKHRProc>(
-      GetGLProcAddress("eglClientWaitSyncKHR"));
+  fn.eglClientWaitSyncKHRFn =
+      reinterpret_cast<eglClientWaitSyncKHRProc>(eglClientWaitSyncKHRNotBound);
   fn.eglCopyBuffersFn =
       reinterpret_cast<eglCopyBuffersProc>(GetGLProcAddress("eglCopyBuffers"));
   fn.eglCreateContextFn = reinterpret_cast<eglCreateContextProc>(
       GetGLProcAddress("eglCreateContext"));
-  fn.eglCreateImageKHRFn = reinterpret_cast<eglCreateImageKHRProc>(
-      GetGLProcAddress("eglCreateImageKHR"));
+  fn.eglCreateImageKHRFn =
+      reinterpret_cast<eglCreateImageKHRProc>(eglCreateImageKHRNotBound);
   fn.eglCreatePbufferFromClientBufferFn =
       reinterpret_cast<eglCreatePbufferFromClientBufferProc>(
           GetGLProcAddress("eglCreatePbufferFromClientBuffer"));
   fn.eglCreatePbufferSurfaceFn = reinterpret_cast<eglCreatePbufferSurfaceProc>(
       GetGLProcAddress("eglCreatePbufferSurface"));
   fn.eglCreatePixmapSurfaceFn = reinterpret_cast<eglCreatePixmapSurfaceProc>(
       GetGLProcAddress("eglCreatePixmapSurface"));
-  fn.eglCreateSyncKHRFn = reinterpret_cast<eglCreateSyncKHRProc>(
-      GetGLProcAddress("eglCreateSyncKHR"));
+  fn.eglCreateSyncKHRFn =
+      reinterpret_cast<eglCreateSyncKHRProc>(eglCreateSyncKHRNotBound);
   fn.eglCreateWindowSurfaceFn = reinterpret_cast<eglCreateWindowSurfaceProc>(
       GetGLProcAddress("eglCreateWindowSurface"));
   fn.eglDestroyContextFn = reinterpret_cast<eglDestroyContextProc>(
       GetGLProcAddress("eglDestroyContext"));
-  fn.eglDestroyImageKHRFn = reinterpret_cast<eglDestroyImageKHRProc>(
-      GetGLProcAddress("eglDestroyImageKHR"));
+  fn.eglDestroyImageKHRFn =
+      reinterpret_cast<eglDestroyImageKHRProc>(eglDestroyImageKHRNotBound);
   fn.eglDestroySurfaceFn = reinterpret_cast<eglDestroySurfaceProc>(
       GetGLProcAddress("eglDestroySurface"));
-  fn.eglDestroySyncKHRFn = reinterpret_cast<eglDestroySyncKHRProc>(
-      GetGLProcAddress("eglDestroySyncKHR"));
+  fn.eglDestroySyncKHRFn =
+      reinterpret_cast<eglDestroySyncKHRProc>(eglDestroySyncKHRNotBound);
   fn.eglGetConfigAttribFn = reinterpret_cast<eglGetConfigAttribProc>(
       GetGLProcAddress("eglGetConfigAttrib"));
   fn.eglGetConfigsFn =
       reinterpret_cast<eglGetConfigsProc>(GetGLProcAddress("eglGetConfigs"));
   fn.eglGetCurrentContextFn = reinterpret_cast<eglGetCurrentContextProc>(
       GetGLProcAddress("eglGetCurrentContext"));
   fn.eglGetCurrentDisplayFn = reinterpret_cast<eglGetCurrentDisplayProc>(
       GetGLProcAddress("eglGetCurrentDisplay"));
   fn.eglGetCurrentSurfaceFn = reinterpret_cast<eglGetCurrentSurfaceProc>(
       GetGLProcAddress("eglGetCurrentSurface"));
   fn.eglGetDisplayFn =
       reinterpret_cast<eglGetDisplayProc>(GetGLProcAddress("eglGetDisplay"));
   fn.eglGetErrorFn =
       reinterpret_cast<eglGetErrorProc>(GetGLProcAddress("eglGetError"));
   fn.eglGetPlatformDisplayEXTFn =
       reinterpret_cast<eglGetPlatformDisplayEXTProc>(
-          GetGLProcAddress("eglGetPlatformDisplayEXT"));
+          eglGetPlatformDisplayEXTNotBound);
   fn.eglGetProcAddressFn = reinterpret_cast<eglGetProcAddressProc>(
       GetGLProcAddress("eglGetProcAddress"));
-  fn.eglGetSyncAttribKHRFn = reinterpret_cast<eglGetSyncAttribKHRProc>(
-      GetGLProcAddress("eglGetSyncAttribKHR"));
+  fn.eglGetSyncAttribKHRFn =
+      reinterpret_cast<eglGetSyncAttribKHRProc>(eglGetSyncAttribKHRNotBound);
   fn.eglGetSyncValuesCHROMIUMFn =
       reinterpret_cast<eglGetSyncValuesCHROMIUMProc>(
-          GetGLProcAddress("eglGetSyncValuesCHROMIUM"));
+          eglGetSyncValuesCHROMIUMNotBound);
   fn.eglInitializeFn =
       reinterpret_cast<eglInitializeProc>(GetGLProcAddress("eglInitialize"));
   fn.eglMakeCurrentFn =
       reinterpret_cast<eglMakeCurrentProc>(GetGLProcAddress("eglMakeCurrent"));
-  fn.eglPostSubBufferNVFn = reinterpret_cast<eglPostSubBufferNVProc>(
-      GetGLProcAddress("eglPostSubBufferNV"));
+  fn.eglPostSubBufferNVFn =
+      reinterpret_cast<eglPostSubBufferNVProc>(eglPostSubBufferNVNotBound);
   fn.eglQueryAPIFn =
       reinterpret_cast<eglQueryAPIProc>(GetGLProcAddress("eglQueryAPI"));
   fn.eglQueryContextFn = reinterpret_cast<eglQueryContextProc>(
       GetGLProcAddress("eglQueryContext"));
   fn.eglQueryStringFn =
       reinterpret_cast<eglQueryStringProc>(GetGLProcAddress("eglQueryString"));
   fn.eglQuerySurfaceFn = reinterpret_cast<eglQuerySurfaceProc>(
       GetGLProcAddress("eglQuerySurface"));
   fn.eglQuerySurfacePointerANGLEFn =
       reinterpret_cast<eglQuerySurfacePointerANGLEProc>(
-          GetGLProcAddress("eglQuerySurfacePointerANGLE"));
+          eglQuerySurfacePointerANGLENotBound);
   fn.eglReleaseTexImageFn = reinterpret_cast<eglReleaseTexImageProc>(
       GetGLProcAddress("eglReleaseTexImage"));
   fn.eglReleaseThreadFn = reinterpret_cast<eglReleaseThreadProc>(
       GetGLProcAddress("eglReleaseThread"));
   fn.eglSurfaceAttribFn = reinterpret_cast<eglSurfaceAttribProc>(
       GetGLProcAddress("eglSurfaceAttrib"));
   fn.eglSwapBuffersFn =
       reinterpret_cast<eglSwapBuffersProc>(GetGLProcAddress("eglSwapBuffers"));
   fn.eglSwapIntervalFn = reinterpret_cast<eglSwapIntervalProc>(
       GetGLProcAddress("eglSwapInterval"));
   fn.eglTerminateFn =
       reinterpret_cast<eglTerminateProc>(GetGLProcAddress("eglTerminate"));
   fn.eglWaitClientFn =
       reinterpret_cast<eglWaitClientProc>(GetGLProcAddress("eglWaitClient"));
   fn.eglWaitGLFn =
       reinterpret_cast<eglWaitGLProc>(GetGLProcAddress("eglWaitGL"));
   fn.eglWaitNativeFn =
       reinterpret_cast<eglWaitNativeProc>(GetGLProcAddress("eglWaitNative"));
   fn.eglWaitSyncKHRFn =
-      reinterpret_cast<eglWaitSyncKHRProc>(GetGLProcAddress("eglWaitSyncKHR"));
-}
-
-void DriverEGL::InitializeDynamicBindings(GLContext* context) {
-  DCHECK(context && context->IsCurrent(NULL));
-  const GLVersionInfo* ver = context->GetVersionInfo();
-  ALLOW_UNUSED_LOCAL(ver);
-  std::string extensions = context->GetExtensions() + " ";
+      reinterpret_cast<eglWaitSyncKHRProc>(eglWaitSyncKHRNotBound);
+  std::string extensions(GetPlatformExtensions());
+  extensions += " ";
   ALLOW_UNUSED_LOCAL(extensions);
 
   ext.b_EGL_ANGLE_d3d_share_handle_client_buffer =
       extensions.find("EGL_ANGLE_d3d_share_handle_client_buffer ") !=
       std::string::npos;
   ext.b_EGL_ANGLE_platform_angle =
       extensions.find("EGL_ANGLE_platform_angle ") != std::string::npos;
   ext.b_EGL_ANGLE_query_surface_pointer =
       extensions.find("EGL_ANGLE_query_surface_pointer ") != std::string::npos;
   ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle =
       extensions.find("EGL_ANGLE_surface_d3d_texture_2d_share_handle ") !=
       std::string::npos;
   ext.b_EGL_CHROMIUM_sync_control =
       extensions.find("EGL_CHROMIUM_sync_control ") != std::string::npos;
   ext.b_EGL_KHR_fence_sync =
       extensions.find("EGL_KHR_fence_sync ") != std::string::npos;
   ext.b_EGL_KHR_gl_texture_2D_image =
       extensions.find("EGL_KHR_gl_texture_2D_image ") != std::string::npos;
+  ext.b_EGL_KHR_image = extensions.find("EGL_KHR_image ") != std::string::npos;
   ext.b_EGL_KHR_image_base =
       extensions.find("EGL_KHR_image_base ") != std::string::npos;
+  ext.b_EGL_KHR_reusable_sync =
+      extensions.find("EGL_KHR_reusable_sync ") != std::string::npos;
   ext.b_EGL_KHR_wait_sync =
       extensions.find("EGL_KHR_wait_sync ") != std::string::npos;
   ext.b_EGL_NV_post_sub_buffer =
       extensions.find("EGL_NV_post_sub_buffer ") != std::string::npos;
 
+  fn.eglClientWaitSyncKHRFn = 0;
+  debug_fn.eglClientWaitSyncKHRFn = 0;
+  if ((ext.b_EGL_KHR_fence_sync || ext.b_EGL_KHR_reusable_sync)) {
+    fn.eglClientWaitSyncKHRFn = reinterpret_cast<eglClientWaitSyncKHRProc>(
+        GetGLProcAddress("eglClientWaitSyncKHR"));
+  } else {
+    fn.eglClientWaitSyncKHRFn = reinterpret_cast<eglClientWaitSyncKHRProc>(
+        eglClientWaitSyncKHRNotBound);
+  }
+  DCHECK(fn.eglClientWaitSyncKHRFn);
+
+  fn.eglCreateImageKHRFn = 0;
+  debug_fn.eglCreateImageKHRFn = 0;
+  if ((ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base ||
+       ext.b_EGL_KHR_gl_texture_2D_image)) {
+    fn.eglCreateImageKHRFn = reinterpret_cast<eglCreateImageKHRProc>(
+        GetGLProcAddress("eglCreateImageKHR"));
+  } else {
+    fn.eglCreateImageKHRFn =
+        reinterpret_cast<eglCreateImageKHRProc>(eglCreateImageKHRNotBound);
+  }
+  DCHECK(fn.eglCreateImageKHRFn);
+
+  fn.eglCreateSyncKHRFn = 0;
+  debug_fn.eglCreateSyncKHRFn = 0;
+  if ((ext.b_EGL_KHR_fence_sync || ext.b_EGL_KHR_reusable_sync)) {
+    fn.eglCreateSyncKHRFn = reinterpret_cast<eglCreateSyncKHRProc>(
+        GetGLProcAddress("eglCreateSyncKHR"));
+  } else {
+    fn.eglCreateSyncKHRFn =
+        reinterpret_cast<eglCreateSyncKHRProc>(eglCreateSyncKHRNotBound);
+  }
+  DCHECK(fn.eglCreateSyncKHRFn);
+
+  fn.eglDestroyImageKHRFn = 0;
+  debug_fn.eglDestroyImageKHRFn = 0;
+  if ((ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base)) {
+    fn.eglDestroyImageKHRFn = reinterpret_cast<eglDestroyImageKHRProc>(
+        GetGLProcAddress("eglDestroyImageKHR"));
+  } else {
+    fn.eglDestroyImageKHRFn =
+        reinterpret_cast<eglDestroyImageKHRProc>(eglDestroyImageKHRNotBound);
+  }
+  DCHECK(fn.eglDestroyImageKHRFn);
+
+  fn.eglDestroySyncKHRFn = 0;
+  debug_fn.eglDestroySyncKHRFn = 0;
+  if ((ext.b_EGL_KHR_fence_sync || ext.b_EGL_KHR_reusable_sync)) {
+    fn.eglDestroySyncKHRFn = reinterpret_cast<eglDestroySyncKHRProc>(
+        GetGLProcAddress("eglDestroySyncKHR"));
+  } else {
+    fn.eglDestroySyncKHRFn =
+        reinterpret_cast<eglDestroySyncKHRProc>(eglDestroySyncKHRNotBound);
+  }
+  DCHECK(fn.eglDestroySyncKHRFn);
+
+  fn.eglGetPlatformDisplayEXTFn = 0;
+  debug_fn.eglGetPlatformDisplayEXTFn = 0;
+  if (ext.b_EGL_ANGLE_platform_angle) {
+    fn.eglGetPlatformDisplayEXTFn =
+        reinterpret_cast<eglGetPlatformDisplayEXTProc>(
+            GetGLProcAddress("eglGetPlatformDisplayEXT"));
+  } else {
+    fn.eglGetPlatformDisplayEXTFn =
+        reinterpret_cast<eglGetPlatformDisplayEXTProc>(
+            eglGetPlatformDisplayEXTNotBound);
+  }
+  DCHECK(fn.eglGetPlatformDisplayEXTFn);
+
+  fn.eglGetSyncAttribKHRFn = 0;
+  debug_fn.eglGetSyncAttribKHRFn = 0;
+  if ((ext.b_EGL_KHR_fence_sync || ext.b_EGL_KHR_reusable_sync)) {
+    fn.eglGetSyncAttribKHRFn = reinterpret_cast<eglGetSyncAttribKHRProc>(
+        GetGLProcAddress("eglGetSyncAttribKHR"));
+  } else {
+    fn.eglGetSyncAttribKHRFn =
+        reinterpret_cast<eglGetSyncAttribKHRProc>(eglGetSyncAttribKHRNotBound);
+  }
+  DCHECK(fn.eglGetSyncAttribKHRFn);
+
+  fn.eglGetSyncValuesCHROMIUMFn = 0;
+  debug_fn.eglGetSyncValuesCHROMIUMFn = 0;
+  if (ext.b_EGL_CHROMIUM_sync_control) {
+    fn.eglGetSyncValuesCHROMIUMFn =
+        reinterpret_cast<eglGetSyncValuesCHROMIUMProc>(
+            GetGLProcAddress("eglGetSyncValuesCHROMIUM"));
+  } else {
+    fn.eglGetSyncValuesCHROMIUMFn =
+        reinterpret_cast<eglGetSyncValuesCHROMIUMProc>(
+            eglGetSyncValuesCHROMIUMNotBound);
+  }
+  DCHECK(fn.eglGetSyncValuesCHROMIUMFn);
+
+  fn.eglPostSubBufferNVFn = 0;
+  debug_fn.eglPostSubBufferNVFn = 0;
+  if (ext.b_EGL_NV_post_sub_buffer) {
+    fn.eglPostSubBufferNVFn = reinterpret_cast<eglPostSubBufferNVProc>(
+        GetGLProcAddress("eglPostSubBufferNV"));
+  } else {
+    fn.eglPostSubBufferNVFn =
+        reinterpret_cast<eglPostSubBufferNVProc>(eglPostSubBufferNVNotBound);
+  }
+  DCHECK(fn.eglPostSubBufferNVFn);
+
+  fn.eglQuerySurfacePointerANGLEFn = 0;
+  debug_fn.eglQuerySurfacePointerANGLEFn = 0;
+  if (ext.b_EGL_ANGLE_query_surface_pointer) {
+    fn.eglQuerySurfacePointerANGLEFn =
+        reinterpret_cast<eglQuerySurfacePointerANGLEProc>(
+            GetGLProcAddress("eglQuerySurfacePointerANGLE"));
+  } else {
+    fn.eglQuerySurfacePointerANGLEFn =
+        reinterpret_cast<eglQuerySurfacePointerANGLEProc>(
+            eglQuerySurfacePointerANGLENotBound);
+  }
+  DCHECK(fn.eglQuerySurfacePointerANGLEFn);
+
+  fn.eglWaitSyncKHRFn = 0;
+  debug_fn.eglWaitSyncKHRFn = 0;
+  if ((ext.b_EGL_KHR_fence_sync || ext.b_EGL_KHR_wait_sync)) {
+    fn.eglWaitSyncKHRFn = reinterpret_cast<eglWaitSyncKHRProc>(
+        GetGLProcAddress("eglWaitSyncKHR"));
+  } else {
+    fn.eglWaitSyncKHRFn =
+        reinterpret_cast<eglWaitSyncKHRProc>(eglWaitSyncKHRNotBound);
+  }
+  DCHECK(fn.eglWaitSyncKHRFn);
+
   if (g_debugBindingsInitialized)
     InitializeDebugBindings();
 }
 
 extern "C" {
 
 static EGLBoolean GL_BINDING_CALL Debug_eglBindAPI(EGLenum api) {
   GL_SERVICE_LOG("eglBindAPI"
                  << "(" << api << ")");
   EGLBoolean result = g_driver_egl.debug_fn.eglBindAPIFn(api);
@@ skipping 1256 matching lines @@
 }
 
 EGLint TraceEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
                                      EGLSyncKHR sync,
                                      EGLint flags) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitSyncKHR")
   return egl_api_->eglWaitSyncKHRFn(dpy, sync, flags);
 }
 
 }  // namespace gfx