Add EGL stream extension bindings

ui/gl/gl_bindings_autogen_egl.cc

Index: ui/gl/gl_bindings_autogen_egl.cc
diff --git a/ui/gl/gl_bindings_autogen_egl.cc b/ui/gl/gl_bindings_autogen_egl.cc
index c2461d8ed9ba9245cb705854787f2316073044db..0c7e97f833a4450a90296c1ffb9f6505e3fdefe0 100644
--- a/ui/gl/gl_bindings_autogen_egl.cc
+++ b/ui/gl/gl_bindings_autogen_egl.cc
@@ -44,6 +44,8 @@ void DriverEGL::InitializeStaticBindings() {
       GetGLProcAddress("eglCreatePbufferSurface"));
   fn.eglCreatePixmapSurfaceFn = reinterpret_cast<eglCreatePixmapSurfaceProc>(
       GetGLProcAddress("eglCreatePixmapSurface"));
+  fn.eglCreateStreamKHRFn = 0;
+  fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn = 0;
   fn.eglCreateSyncKHRFn = reinterpret_cast<eglCreateSyncKHRProc>(
       GetGLProcAddress("eglCreateSyncKHR"));
   fn.eglCreateWindowSurfaceFn = reinterpret_cast<eglCreateWindowSurfaceProc>(
@@ -51,6 +53,7 @@ void DriverEGL::InitializeStaticBindings() {
   fn.eglDestroyContextFn = reinterpret_cast<eglDestroyContextProc>(
       GetGLProcAddress("eglDestroyContext"));
   fn.eglDestroyImageKHRFn = 0;
+  fn.eglDestroyStreamKHRFn = 0;
   fn.eglDestroySurfaceFn = reinterpret_cast<eglDestroySurfaceProc>(
       GetGLProcAddress("eglDestroySurface"));
   fn.eglDestroySyncKHRFn = reinterpret_cast<eglDestroySyncKHRProc>(
@@ -84,6 +87,8 @@ void DriverEGL::InitializeStaticBindings() {
       reinterpret_cast<eglQueryAPIProc>(GetGLProcAddress("eglQueryAPI"));
   fn.eglQueryContextFn = reinterpret_cast<eglQueryContextProc>(
       GetGLProcAddress("eglQueryContext"));
+  fn.eglQueryStreamKHRFn = 0;
+  fn.eglQueryStreamu64KHRFn = 0;
   fn.eglQueryStringFn =
       reinterpret_cast<eglQueryStringProc>(GetGLProcAddress("eglQueryString"));
   fn.eglQuerySurfaceFn = reinterpret_cast<eglQuerySurfaceProc>(
@@ -93,6 +98,12 @@ void DriverEGL::InitializeStaticBindings() {
       GetGLProcAddress("eglReleaseTexImage"));
   fn.eglReleaseThreadFn = reinterpret_cast<eglReleaseThreadProc>(
       GetGLProcAddress("eglReleaseThread"));
+  fn.eglStreamAttribKHRFn = 0;
+  fn.eglStreamConsumerAcquireKHRFn = 0;
+  fn.eglStreamConsumerGLTextureExternalAttribsNVFn = 0;
+  fn.eglStreamConsumerGLTextureExternalKHRFn = 0;
+  fn.eglStreamConsumerReleaseKHRFn = 0;
+  fn.eglStreamPostD3DTextureNV12ANGLEFn = 0;
   fn.eglSurfaceAttribFn = reinterpret_cast<eglSurfaceAttribProc>(
       GetGLProcAddress("eglSurfaceAttrib"));
   fn.eglSwapBuffersFn =
@@ -133,6 +144,9 @@ void DriverEGL::InitializeExtensionBindings() {
       std::string::npos;
   ext.b_EGL_ANGLE_query_surface_pointer =
       extensions.find("EGL_ANGLE_query_surface_pointer ") != std::string::npos;
+  ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12 =
+      extensions.find("EGL_ANGLE_stream_producer_d3d_texture_nv12 ") !=
+      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;
@@ -147,10 +161,18 @@ void DriverEGL::InitializeExtensionBindings() {
       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_stream =
+      extensions.find("EGL_KHR_stream ") != std::string::npos;
+  ext.b_EGL_KHR_stream_consumer_gltexture =
+      extensions.find("EGL_KHR_stream_consumer_gltexture ") !=
+      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;
+  ext.b_EGL_NV_stream_consumer_gltexture_yuv =
+      extensions.find("EGL_NV_stream_consumer_gltexture_yuv ") !=
+      std::string::npos;
   ext.b_GL_CHROMIUM_egl_khr_fence_sync_hack =
       extensions.find("GL_CHROMIUM_egl_khr_fence_sync_hack ") !=
       std::string::npos;
@@ -162,12 +184,31 @@ void DriverEGL::InitializeExtensionBindings() {
         GetGLProcAddress("eglCreateImageKHR"));
   }
 
+  debug_fn.eglCreateStreamKHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglCreateStreamKHRFn = reinterpret_cast<eglCreateStreamKHRProc>(
+        GetGLProcAddress("eglCreateStreamKHR"));
+  }
+
+  debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn = 0;
+  if (ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12) {
+    fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
+        reinterpret_cast<eglCreateStreamProducerD3DTextureNV12ANGLEProc>(
+            GetGLProcAddress("eglCreateStreamProducerD3DTextureNV12ANGLE"));
+  }
+
   debug_fn.eglDestroyImageKHRFn = 0;
   if (ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base) {
     fn.eglDestroyImageKHRFn = reinterpret_cast<eglDestroyImageKHRProc>(
         GetGLProcAddress("eglDestroyImageKHR"));
   }
 
+  debug_fn.eglDestroyStreamKHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglDestroyStreamKHRFn = reinterpret_cast<eglDestroyStreamKHRProc>(
+        GetGLProcAddress("eglDestroyStreamKHR"));
+  }
+
   debug_fn.eglGetSyncValuesCHROMIUMFn = 0;
   if (ext.b_EGL_CHROMIUM_sync_control) {
     fn.eglGetSyncValuesCHROMIUMFn =
@@ -181,6 +222,18 @@ void DriverEGL::InitializeExtensionBindings() {
         GetGLProcAddress("eglPostSubBufferNV"));
   }
 
+  debug_fn.eglQueryStreamKHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglQueryStreamKHRFn = reinterpret_cast<eglQueryStreamKHRProc>(
+        GetGLProcAddress("eglQueryStreamKHR"));
+  }
+
+  debug_fn.eglQueryStreamu64KHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglQueryStreamu64KHRFn = reinterpret_cast<eglQueryStreamu64KHRProc>(
+        GetGLProcAddress("eglQueryStreamu64KHR"));
+  }
+
   debug_fn.eglQuerySurfacePointerANGLEFn = 0;
   if (ext.b_EGL_ANGLE_query_surface_pointer) {
     fn.eglQuerySurfacePointerANGLEFn =
@@ -188,6 +241,47 @@ void DriverEGL::InitializeExtensionBindings() {
             GetGLProcAddress("eglQuerySurfacePointerANGLE"));
   }
 
+  debug_fn.eglStreamAttribKHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglStreamAttribKHRFn = reinterpret_cast<eglStreamAttribKHRProc>(
+        GetGLProcAddress("eglStreamAttribKHR"));
+  }
+
+  debug_fn.eglStreamConsumerAcquireKHRFn = 0;
+  if (ext.b_EGL_KHR_stream_consumer_gltexture) {
+    fn.eglStreamConsumerAcquireKHRFn =
+        reinterpret_cast<eglStreamConsumerAcquireKHRProc>(
+            GetGLProcAddress("eglStreamConsumerAcquireKHR"));
+  }
+
+  debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn = 0;
+  if (ext.b_EGL_NV_stream_consumer_gltexture_yuv) {
+    fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
+        reinterpret_cast<eglStreamConsumerGLTextureExternalAttribsNVProc>(
+            GetGLProcAddress("eglStreamConsumerGLTextureExternalAttribsNV"));
+  }
+
+  debug_fn.eglStreamConsumerGLTextureExternalKHRFn = 0;
+  if (ext.b_EGL_KHR_stream_consumer_gltexture) {
+    fn.eglStreamConsumerGLTextureExternalKHRFn =
+        reinterpret_cast<eglStreamConsumerGLTextureExternalKHRProc>(
+            GetGLProcAddress("eglStreamConsumerGLTextureExternalKHR"));
+  }
+
+  debug_fn.eglStreamConsumerReleaseKHRFn = 0;
+  if (ext.b_EGL_KHR_stream_consumer_gltexture) {
+    fn.eglStreamConsumerReleaseKHRFn =
+        reinterpret_cast<eglStreamConsumerReleaseKHRProc>(
+            GetGLProcAddress("eglStreamConsumerReleaseKHR"));
+  }
+
+  debug_fn.eglStreamPostD3DTextureNV12ANGLEFn = 0;
+  if (ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12) {
+    fn.eglStreamPostD3DTextureNV12ANGLEFn =
+        reinterpret_cast<eglStreamPostD3DTextureNV12ANGLEProc>(
+            GetGLProcAddress("eglStreamPostD3DTextureNV12ANGLE"));
+  }
+
   debug_fn.eglWaitSyncKHRFn = 0;
   if (ext.b_EGL_KHR_wait_sync) {
     fn.eglWaitSyncKHRFn = reinterpret_cast<eglWaitSyncKHRProc>(
@@ -344,6 +438,34 @@ Debug_eglCreatePixmapSurface(EGLDisplay dpy,
   return result;
 }
 
+static EGLStreamKHR GL_BINDING_CALL
+Debug_eglCreateStreamKHR(EGLDisplay dpy, const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreateStreamKHR"
+                 << "(" << dpy << ", " << static_cast<const void*>(attrib_list)
+                 << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreateStreamKHRFn != nullptr);
+  EGLStreamKHR result =
+      g_driver_egl.debug_fn.eglCreateStreamKHRFn(dpy, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglCreateStreamProducerD3DTextureNV12ANGLE(EGLDisplay dpy,
+                                                 EGLStreamKHR stream,
+                                                 EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglCreateStreamProducerD3DTextureNV12ANGLE"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn !=
+         nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn(
+          dpy, stream, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static EGLSyncKHR GL_BINDING_CALL
 Debug_eglCreateSyncKHR(EGLDisplay dpy,
                        EGLenum type,
@@ -393,6 +515,16 @@ static EGLBoolean GL_BINDING_CALL Debug_eglDestroyImageKHR(EGLDisplay dpy,
   return result;
 }
 
+static EGLBoolean GL_BINDING_CALL
+Debug_eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglDestroyStreamKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  DCHECK(g_driver_egl.debug_fn.eglDestroyStreamKHRFn != nullptr);
+  EGLBoolean result = g_driver_egl.debug_fn.eglDestroyStreamKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static EGLBoolean GL_BINDING_CALL Debug_eglDestroySurface(EGLDisplay dpy,
                                                           EGLSurface surface) {
   GL_SERVICE_LOG("eglDestroySurface"
@@ -615,6 +747,35 @@ static EGLBoolean GL_BINDING_CALL Debug_eglQueryContext(EGLDisplay dpy,
   return result;
 }
 
+static EGLBoolean GL_BINDING_CALL Debug_eglQueryStreamKHR(EGLDisplay dpy,
+                                                          EGLStreamKHR stream,
+                                                          EGLenum attribute,
+                                                          EGLint* value) {
+  GL_SERVICE_LOG("eglQueryStreamKHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQueryStreamKHRFn != nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglQueryStreamKHRFn(dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglQueryStreamu64KHR(EGLDisplay dpy,
+                           EGLStreamKHR stream,
+                           EGLenum attribute,
+                           EGLuint64KHR* value) {
+  GL_SERVICE_LOG("eglQueryStreamu64KHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQueryStreamu64KHRFn != nullptr);
+  EGLBoolean result = g_driver_egl.debug_fn.eglQueryStreamu64KHRFn(
+      dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static const char* GL_BINDING_CALL Debug_eglQueryString(EGLDisplay dpy,
                                                         EGLint name) {
   GL_SERVICE_LOG("eglQueryString"
@@ -676,6 +837,88 @@ static EGLBoolean GL_BINDING_CALL Debug_eglReleaseThread(void) {
   return result;
 }
 
+static EGLBoolean GL_BINDING_CALL Debug_eglStreamAttribKHR(EGLDisplay dpy,
+                                                           EGLStreamKHR stream,
+                                                           EGLenum attribute,
+                                                           EGLint value) {
+  GL_SERVICE_LOG("eglStreamAttribKHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << value << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamAttribKHRFn != nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamAttribKHRFn(dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerAcquireKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerAcquireKHRFn != nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamConsumerAcquireKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
+                                                  EGLStreamKHR stream,
+                                                  EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalAttribsNV"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn !=
+         nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn(
+          dpy, stream, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy,
+                                            EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalKHRFn !=
+         nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalKHRFn(dpy,
+                                                                    stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerReleaseKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerReleaseKHRFn != nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamConsumerReleaseKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamPostD3DTextureNV12ANGLE(EGLDisplay dpy,
+                                       EGLStreamKHR stream,
+                                       void* texture,
+                                       const EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglStreamPostD3DTextureNV12ANGLE"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(texture) << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamPostD3DTextureNV12ANGLEFn != nullptr);
+  EGLBoolean result = g_driver_egl.debug_fn.eglStreamPostD3DTextureNV12ANGLEFn(
+      dpy, stream, texture, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static EGLBoolean GL_BINDING_CALL Debug_eglSurfaceAttrib(EGLDisplay dpy,
                                                          EGLSurface surface,
                                                          EGLint attribute,
@@ -803,6 +1046,16 @@ void DriverEGL::InitializeDebugBindings() {
     debug_fn.eglCreatePixmapSurfaceFn = fn.eglCreatePixmapSurfaceFn;
     fn.eglCreatePixmapSurfaceFn = Debug_eglCreatePixmapSurface;
   }
+  if (!debug_fn.eglCreateStreamKHRFn) {
+    debug_fn.eglCreateStreamKHRFn = fn.eglCreateStreamKHRFn;
+    fn.eglCreateStreamKHRFn = Debug_eglCreateStreamKHR;
+  }
+  if (!debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn) {
+    debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
+        fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn;
+    fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
+        Debug_eglCreateStreamProducerD3DTextureNV12ANGLE;
+  }
   if (!debug_fn.eglCreateSyncKHRFn) {
     debug_fn.eglCreateSyncKHRFn = fn.eglCreateSyncKHRFn;
     fn.eglCreateSyncKHRFn = Debug_eglCreateSyncKHR;
@@ -819,6 +1072,10 @@ void DriverEGL::InitializeDebugBindings() {
     debug_fn.eglDestroyImageKHRFn = fn.eglDestroyImageKHRFn;
     fn.eglDestroyImageKHRFn = Debug_eglDestroyImageKHR;
   }
+  if (!debug_fn.eglDestroyStreamKHRFn) {
+    debug_fn.eglDestroyStreamKHRFn = fn.eglDestroyStreamKHRFn;
+    fn.eglDestroyStreamKHRFn = Debug_eglDestroyStreamKHR;
+  }
   if (!debug_fn.eglDestroySurfaceFn) {
     debug_fn.eglDestroySurfaceFn = fn.eglDestroySurfaceFn;
     fn.eglDestroySurfaceFn = Debug_eglDestroySurface;
@@ -891,6 +1148,14 @@ void DriverEGL::InitializeDebugBindings() {
     debug_fn.eglQueryContextFn = fn.eglQueryContextFn;
     fn.eglQueryContextFn = Debug_eglQueryContext;
   }
+  if (!debug_fn.eglQueryStreamKHRFn) {
+    debug_fn.eglQueryStreamKHRFn = fn.eglQueryStreamKHRFn;
+    fn.eglQueryStreamKHRFn = Debug_eglQueryStreamKHR;
+  }
+  if (!debug_fn.eglQueryStreamu64KHRFn) {
+    debug_fn.eglQueryStreamu64KHRFn = fn.eglQueryStreamu64KHRFn;
+    fn.eglQueryStreamu64KHRFn = Debug_eglQueryStreamu64KHR;
+  }
   if (!debug_fn.eglQueryStringFn) {
     debug_fn.eglQueryStringFn = fn.eglQueryStringFn;
     fn.eglQueryStringFn = Debug_eglQueryString;
@@ -911,6 +1176,36 @@ void DriverEGL::InitializeDebugBindings() {
     debug_fn.eglReleaseThreadFn = fn.eglReleaseThreadFn;
     fn.eglReleaseThreadFn = Debug_eglReleaseThread;
   }
+  if (!debug_fn.eglStreamAttribKHRFn) {
+    debug_fn.eglStreamAttribKHRFn = fn.eglStreamAttribKHRFn;
+    fn.eglStreamAttribKHRFn = Debug_eglStreamAttribKHR;
+  }
+  if (!debug_fn.eglStreamConsumerAcquireKHRFn) {
+    debug_fn.eglStreamConsumerAcquireKHRFn = fn.eglStreamConsumerAcquireKHRFn;
+    fn.eglStreamConsumerAcquireKHRFn = Debug_eglStreamConsumerAcquireKHR;
+  }
+  if (!debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn) {
+    debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
+        fn.eglStreamConsumerGLTextureExternalAttribsNVFn;
+    fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
+        Debug_eglStreamConsumerGLTextureExternalAttribsNV;
+  }
+  if (!debug_fn.eglStreamConsumerGLTextureExternalKHRFn) {
+    debug_fn.eglStreamConsumerGLTextureExternalKHRFn =
+        fn.eglStreamConsumerGLTextureExternalKHRFn;
+    fn.eglStreamConsumerGLTextureExternalKHRFn =
+        Debug_eglStreamConsumerGLTextureExternalKHR;
+  }
+  if (!debug_fn.eglStreamConsumerReleaseKHRFn) {
+    debug_fn.eglStreamConsumerReleaseKHRFn = fn.eglStreamConsumerReleaseKHRFn;
+    fn.eglStreamConsumerReleaseKHRFn = Debug_eglStreamConsumerReleaseKHR;
+  }
+  if (!debug_fn.eglStreamPostD3DTextureNV12ANGLEFn) {
+    debug_fn.eglStreamPostD3DTextureNV12ANGLEFn =
+        fn.eglStreamPostD3DTextureNV12ANGLEFn;
+    fn.eglStreamPostD3DTextureNV12ANGLEFn =
+        Debug_eglStreamPostD3DTextureNV12ANGLE;
+  }
   if (!debug_fn.eglSurfaceAttribFn) {
     debug_fn.eglSurfaceAttribFn = fn.eglSurfaceAttribFn;
     fn.eglSurfaceAttribFn = Debug_eglSurfaceAttrib;
@@ -1021,6 +1316,19 @@ EGLSurface EGLApiBase::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
   return driver_->fn.eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
 }
 
+EGLStreamKHR EGLApiBase::eglCreateStreamKHRFn(EGLDisplay dpy,
+                                              const EGLint* attrib_list) {
+  return driver_->fn.eglCreateStreamKHRFn(dpy, attrib_list);
+}
+
+EGLBoolean EGLApiBase::eglCreateStreamProducerD3DTextureNV12ANGLEFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    EGLAttrib* attrib_list) {
+  return driver_->fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn(dpy, stream,
+                                                                  attrib_list);
+}
+
 EGLSyncKHR EGLApiBase::eglCreateSyncKHRFn(EGLDisplay dpy,
                                           EGLenum type,
                                           const EGLint* attrib_list) {
@@ -1042,6 +1350,11 @@ EGLBoolean EGLApiBase::eglDestroyImageKHRFn(EGLDisplay dpy, EGLImageKHR image) {
   return driver_->fn.eglDestroyImageKHRFn(dpy, image);
 }
 
+EGLBoolean EGLApiBase::eglDestroyStreamKHRFn(EGLDisplay dpy,
+                                             EGLStreamKHR stream) {
+  return driver_->fn.eglDestroyStreamKHRFn(dpy, stream);
+}
+
 EGLBoolean EGLApiBase::eglDestroySurfaceFn(EGLDisplay dpy, EGLSurface surface) {
   return driver_->fn.eglDestroySurfaceFn(dpy, surface);
 }
@@ -1144,6 +1457,20 @@ EGLBoolean EGLApiBase::eglQueryContextFn(EGLDisplay dpy,
   return driver_->fn.eglQueryContextFn(dpy, ctx, attribute, value);
 }
 
+EGLBoolean EGLApiBase::eglQueryStreamKHRFn(EGLDisplay dpy,
+                                           EGLStreamKHR stream,
+                                           EGLenum attribute,
+                                           EGLint* value) {
+  return driver_->fn.eglQueryStreamKHRFn(dpy, stream, attribute, value);
+}
+
+EGLBoolean EGLApiBase::eglQueryStreamu64KHRFn(EGLDisplay dpy,
+                                              EGLStreamKHR stream,
+                                              EGLenum attribute,
+                                              EGLuint64KHR* value) {
+  return driver_->fn.eglQueryStreamu64KHRFn(dpy, stream, attribute, value);
+}
+
 const char* EGLApiBase::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
   return driver_->fn.eglQueryStringFn(dpy, name);
 }
@@ -1173,6 +1500,46 @@ EGLBoolean EGLApiBase::eglReleaseThreadFn(void) {
   return driver_->fn.eglReleaseThreadFn();
 }
 
+EGLBoolean EGLApiBase::eglStreamAttribKHRFn(EGLDisplay dpy,
+                                            EGLStreamKHR stream,
+                                            EGLenum attribute,
+                                            EGLint value) {
+  return driver_->fn.eglStreamAttribKHRFn(dpy, stream, attribute, value);
+}
+
+EGLBoolean EGLApiBase::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
+                                                     EGLStreamKHR stream) {
+  return driver_->fn.eglStreamConsumerAcquireKHRFn(dpy, stream);
+}
+
+EGLBoolean EGLApiBase::eglStreamConsumerGLTextureExternalAttribsNVFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    EGLAttrib* attrib_list) {
+  return driver_->fn.eglStreamConsumerGLTextureExternalAttribsNVFn(dpy, stream,
+                                                                   attrib_list);
+}
+
+EGLBoolean EGLApiBase::eglStreamConsumerGLTextureExternalKHRFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream) {
+  return driver_->fn.eglStreamConsumerGLTextureExternalKHRFn(dpy, stream);
+}
+
+EGLBoolean EGLApiBase::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
+                                                     EGLStreamKHR stream) {
+  return driver_->fn.eglStreamConsumerReleaseKHRFn(dpy, stream);
+}
+
+EGLBoolean EGLApiBase::eglStreamPostD3DTextureNV12ANGLEFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    void* texture,
+    const EGLAttrib* attrib_list) {
+  return driver_->fn.eglStreamPostD3DTextureNV12ANGLEFn(dpy, stream, texture,
+                                                        attrib_list);
+}
+
 EGLBoolean EGLApiBase::eglSurfaceAttribFn(EGLDisplay dpy,
                                           EGLSurface surface,
                                           EGLint attribute,
@@ -1291,6 +1658,22 @@ EGLSurface TraceEGLApi::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
   return egl_api_->eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
 }
 
+EGLStreamKHR TraceEGLApi::eglCreateStreamKHRFn(EGLDisplay dpy,
+                                               const EGLint* attrib_list) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreateStreamKHR")
+  return egl_api_->eglCreateStreamKHRFn(dpy, attrib_list);
+}
+
+EGLBoolean TraceEGLApi::eglCreateStreamProducerD3DTextureNV12ANGLEFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    EGLAttrib* attrib_list) {
+  TRACE_EVENT_BINARY_EFFICIENT0(
+      "gpu", "TraceGLAPI::eglCreateStreamProducerD3DTextureNV12ANGLE")
+  return egl_api_->eglCreateStreamProducerD3DTextureNV12ANGLEFn(dpy, stream,
+                                                                attrib_list);
+}
+
 EGLSyncKHR TraceEGLApi::eglCreateSyncKHRFn(EGLDisplay dpy,
                                            EGLenum type,
                                            const EGLint* attrib_list) {
@@ -1317,6 +1700,12 @@ EGLBoolean TraceEGLApi::eglDestroyImageKHRFn(EGLDisplay dpy,
   return egl_api_->eglDestroyImageKHRFn(dpy, image);
 }
 
+EGLBoolean TraceEGLApi::eglDestroyStreamKHRFn(EGLDisplay dpy,
+                                              EGLStreamKHR stream) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroyStreamKHR")
+  return egl_api_->eglDestroyStreamKHRFn(dpy, stream);
+}
+
 EGLBoolean TraceEGLApi::eglDestroySurfaceFn(EGLDisplay dpy,
                                             EGLSurface surface) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroySurface")
@@ -1438,6 +1827,22 @@ EGLBoolean TraceEGLApi::eglQueryContextFn(EGLDisplay dpy,
   return egl_api_->eglQueryContextFn(dpy, ctx, attribute, value);
 }
 
+EGLBoolean TraceEGLApi::eglQueryStreamKHRFn(EGLDisplay dpy,
+                                            EGLStreamKHR stream,
+                                            EGLenum attribute,
+                                            EGLint* value) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryStreamKHR")
+  return egl_api_->eglQueryStreamKHRFn(dpy, stream, attribute, value);
+}
+
+EGLBoolean TraceEGLApi::eglQueryStreamu64KHRFn(EGLDisplay dpy,
+                                               EGLStreamKHR stream,
+                                               EGLenum attribute,
+                                               EGLuint64KHR* value) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryStreamu64KHR")
+  return egl_api_->eglQueryStreamu64KHRFn(dpy, stream, attribute, value);
+}
+
 const char* TraceEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryString")
   return egl_api_->eglQueryStringFn(dpy, name);
@@ -1473,6 +1878,57 @@ EGLBoolean TraceEGLApi::eglReleaseThreadFn(void) {
   return egl_api_->eglReleaseThreadFn();
 }
 
+EGLBoolean TraceEGLApi::eglStreamAttribKHRFn(EGLDisplay dpy,
+                                             EGLStreamKHR stream,
+                                             EGLenum attribute,
+                                             EGLint value) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglStreamAttribKHR")
+  return egl_api_->eglStreamAttribKHRFn(dpy, stream, attribute, value);
+}
+
+EGLBoolean TraceEGLApi::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
+                                                      EGLStreamKHR stream) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::eglStreamConsumerAcquireKHR")
+  return egl_api_->eglStreamConsumerAcquireKHRFn(dpy, stream);
+}
+
+EGLBoolean TraceEGLApi::eglStreamConsumerGLTextureExternalAttribsNVFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    EGLAttrib* attrib_list) {
+  TRACE_EVENT_BINARY_EFFICIENT0(
+      "gpu", "TraceGLAPI::eglStreamConsumerGLTextureExternalAttribsNV")
+  return egl_api_->eglStreamConsumerGLTextureExternalAttribsNVFn(dpy, stream,
+                                                                 attrib_list);
+}
+
+EGLBoolean TraceEGLApi::eglStreamConsumerGLTextureExternalKHRFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream) {
+  TRACE_EVENT_BINARY_EFFICIENT0(
+      "gpu", "TraceGLAPI::eglStreamConsumerGLTextureExternalKHR")
+  return egl_api_->eglStreamConsumerGLTextureExternalKHRFn(dpy, stream);
+}
+
+EGLBoolean TraceEGLApi::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
+                                                      EGLStreamKHR stream) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::eglStreamConsumerReleaseKHR")
+  return egl_api_->eglStreamConsumerReleaseKHRFn(dpy, stream);
+}
+
+EGLBoolean TraceEGLApi::eglStreamPostD3DTextureNV12ANGLEFn(
+    EGLDisplay dpy,
+    EGLStreamKHR stream,
+    void* texture,
+    const EGLAttrib* attrib_list) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::eglStreamPostD3DTextureNV12ANGLE")
+  return egl_api_->eglStreamPostD3DTextureNV12ANGLEFn(dpy, stream, texture,
+                                                      attrib_list);
+}
+
 EGLBoolean TraceEGLApi::eglSurfaceAttribFn(EGLDisplay dpy,
                                            EGLSurface surface,
                                            EGLint attribute,