Add EGL stream extension bindings

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!
 
@@ skipping 26 matching lines @@
   fn.eglCreateContextFn = reinterpret_cast<eglCreateContextProc>(
       GetGLProcAddress("eglCreateContext"));
   fn.eglCreateImageKHRFn = 0;
   fn.eglCreatePbufferFromClientBufferFn =
       reinterpret_cast<eglCreatePbufferFromClientBufferProc>(
           GetGLProcAddress("eglCreatePbufferFromClientBuffer"));
   fn.eglCreatePbufferSurfaceFn = reinterpret_cast<eglCreatePbufferSurfaceProc>(
       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>(
       GetGLProcAddress("eglCreateWindowSurface"));
   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>(
       GetGLProcAddress("eglDestroySyncKHR"));
   fn.eglGetConfigAttribFn = reinterpret_cast<eglGetConfigAttribProc>(
       GetGLProcAddress("eglGetConfigAttrib"));
   fn.eglGetConfigsFn =
       reinterpret_cast<eglGetConfigsProc>(GetGLProcAddress("eglGetConfigs"));
   fn.eglGetCurrentContextFn = reinterpret_cast<eglGetCurrentContextProc>(
       GetGLProcAddress("eglGetCurrentContext"));
@@ skipping 13 matching lines @@
   fn.eglGetSyncValuesCHROMIUMFn = 0;
   fn.eglInitializeFn =
       reinterpret_cast<eglInitializeProc>(GetGLProcAddress("eglInitialize"));
   fn.eglMakeCurrentFn =
       reinterpret_cast<eglMakeCurrentProc>(GetGLProcAddress("eglMakeCurrent"));
   fn.eglPostSubBufferNVFn = 0;
   fn.eglQueryAPIFn =
       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>(
       GetGLProcAddress("eglQuerySurface"));
   fn.eglQuerySurfacePointerANGLEFn = 0;
   fn.eglReleaseTexImageFn = reinterpret_cast<eglReleaseTexImageProc>(
       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 =
       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"));
@@ skipping 20 matching lines @@
   }
   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_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;
   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_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;
 
   debug_fn.eglCreateImageKHRFn = 0;
   if (ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base ||
       ext.b_EGL_KHR_gl_texture_2D_image) {
     fn.eglCreateImageKHRFn = reinterpret_cast<eglCreateImageKHRProc>(
         GetGLProcAddress("eglCreateImageKHR"));
   }
 
+  debug_fn.eglCreateStreamKHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglCreateStreamKHRFn = reinterpret_cast<eglCreateStreamKHRProc>(
+        GetGLProcAddress("eglCreateStreamKHR"));
+  }
+
+  debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn = 0;
+  if (ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12) {
+    fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
+        reinterpret_cast<eglCreateStreamProducerD3DTextureNV12ANGLEProc>(
+            GetGLProcAddress("eglCreateStreamProducerD3DTextureNV12ANGLE"));
+  }
+
   debug_fn.eglDestroyImageKHRFn = 0;
   if (ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base) {
     fn.eglDestroyImageKHRFn = reinterpret_cast<eglDestroyImageKHRProc>(
         GetGLProcAddress("eglDestroyImageKHR"));
   }
 
+  debug_fn.eglDestroyStreamKHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglDestroyStreamKHRFn = reinterpret_cast<eglDestroyStreamKHRProc>(
+        GetGLProcAddress("eglDestroyStreamKHR"));
+  }
+
   debug_fn.eglGetSyncValuesCHROMIUMFn = 0;
   if (ext.b_EGL_CHROMIUM_sync_control) {
     fn.eglGetSyncValuesCHROMIUMFn =
         reinterpret_cast<eglGetSyncValuesCHROMIUMProc>(
             GetGLProcAddress("eglGetSyncValuesCHROMIUM"));
   }
 
   debug_fn.eglPostSubBufferNVFn = 0;
   if (ext.b_EGL_NV_post_sub_buffer) {
     fn.eglPostSubBufferNVFn = reinterpret_cast<eglPostSubBufferNVProc>(
         GetGLProcAddress("eglPostSubBufferNV"));
   }
 
+  debug_fn.eglQueryStreamKHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglQueryStreamKHRFn = reinterpret_cast<eglQueryStreamKHRProc>(
+        GetGLProcAddress("eglQueryStreamKHR"));
+  }
+
+  debug_fn.eglQueryStreamu64KHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglQueryStreamu64KHRFn = reinterpret_cast<eglQueryStreamu64KHRProc>(
+        GetGLProcAddress("eglQueryStreamu64KHR"));
+  }
+
   debug_fn.eglQuerySurfacePointerANGLEFn = 0;
   if (ext.b_EGL_ANGLE_query_surface_pointer) {
     fn.eglQuerySurfacePointerANGLEFn =
         reinterpret_cast<eglQuerySurfacePointerANGLEProc>(
             GetGLProcAddress("eglQuerySurfacePointerANGLE"));
   }
 
+  debug_fn.eglStreamAttribKHRFn = 0;
+  if (ext.b_EGL_KHR_stream) {
+    fn.eglStreamAttribKHRFn = reinterpret_cast<eglStreamAttribKHRProc>(
+        GetGLProcAddress("eglStreamAttribKHR"));
+  }
+
+  debug_fn.eglStreamConsumerAcquireKHRFn = 0;
+  if (ext.b_EGL_KHR_stream_consumer_gltexture) {
+    fn.eglStreamConsumerAcquireKHRFn =
+        reinterpret_cast<eglStreamConsumerAcquireKHRProc>(
+            GetGLProcAddress("eglStreamConsumerAcquireKHR"));
+  }
+
+  debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn = 0;
+  if (ext.b_EGL_NV_stream_consumer_gltexture_yuv) {
+    fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
+        reinterpret_cast<eglStreamConsumerGLTextureExternalAttribsNVProc>(
+            GetGLProcAddress("eglStreamConsumerGLTextureExternalAttribsNV"));
+  }
+
+  debug_fn.eglStreamConsumerGLTextureExternalKHRFn = 0;
+  if (ext.b_EGL_KHR_stream_consumer_gltexture) {
+    fn.eglStreamConsumerGLTextureExternalKHRFn =
+        reinterpret_cast<eglStreamConsumerGLTextureExternalKHRProc>(
+            GetGLProcAddress("eglStreamConsumerGLTextureExternalKHR"));
+  }
+
+  debug_fn.eglStreamConsumerReleaseKHRFn = 0;
+  if (ext.b_EGL_KHR_stream_consumer_gltexture) {
+    fn.eglStreamConsumerReleaseKHRFn =
+        reinterpret_cast<eglStreamConsumerReleaseKHRProc>(
+            GetGLProcAddress("eglStreamConsumerReleaseKHR"));
+  }
+
+  debug_fn.eglStreamPostD3DTextureNV12ANGLEFn = 0;
+  if (ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12) {
+    fn.eglStreamPostD3DTextureNV12ANGLEFn =
+        reinterpret_cast<eglStreamPostD3DTextureNV12ANGLEProc>(
+            GetGLProcAddress("eglStreamPostD3DTextureNV12ANGLE"));
+  }
+
   debug_fn.eglWaitSyncKHRFn = 0;
   if (ext.b_EGL_KHR_wait_sync) {
     fn.eglWaitSyncKHRFn = reinterpret_cast<eglWaitSyncKHRProc>(
         GetGLProcAddress("eglWaitSyncKHR"));
   }
 
   if (g_debugBindingsInitialized)
     InitializeDebugBindings();
 }
 
@@ skipping 136 matching lines @@
   GL_SERVICE_LOG("eglCreatePixmapSurface"
                  << "(" << dpy << ", " << config << ", " << pixmap << ", "
                  << static_cast<const void*>(attrib_list) << ")");
   DCHECK(g_driver_egl.debug_fn.eglCreatePixmapSurfaceFn != nullptr);
   EGLSurface result = g_driver_egl.debug_fn.eglCreatePixmapSurfaceFn(
       dpy, config, pixmap, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
+static EGLStreamKHR GL_BINDING_CALL
+Debug_eglCreateStreamKHR(EGLDisplay dpy, const EGLint* attrib_list) {
+  GL_SERVICE_LOG("eglCreateStreamKHR"
+                 << "(" << dpy << ", " << static_cast<const void*>(attrib_list)
+                 << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreateStreamKHRFn != nullptr);
+  EGLStreamKHR result =
+      g_driver_egl.debug_fn.eglCreateStreamKHRFn(dpy, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglCreateStreamProducerD3DTextureNV12ANGLE(EGLDisplay dpy,
+                                                 EGLStreamKHR stream,
+                                                 EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglCreateStreamProducerD3DTextureNV12ANGLE"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn !=
+         nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn(
+          dpy, stream, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static EGLSyncKHR GL_BINDING_CALL
 Debug_eglCreateSyncKHR(EGLDisplay dpy,
                        EGLenum type,
                        const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreateSyncKHR"
                  << "(" << dpy << ", " << type << ", "
                  << static_cast<const void*>(attrib_list) << ")");
   DCHECK(g_driver_egl.debug_fn.eglCreateSyncKHRFn != nullptr);
   EGLSyncKHR result =
       g_driver_egl.debug_fn.eglCreateSyncKHRFn(dpy, type, attrib_list);
@@ skipping 29 matching lines @@
 static EGLBoolean GL_BINDING_CALL Debug_eglDestroyImageKHR(EGLDisplay dpy,
                                                            EGLImageKHR image) {
   GL_SERVICE_LOG("eglDestroyImageKHR"
                  << "(" << dpy << ", " << image << ")");
   DCHECK(g_driver_egl.debug_fn.eglDestroyImageKHRFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroyImageKHRFn(dpy, image);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
+static EGLBoolean GL_BINDING_CALL
+Debug_eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglDestroyStreamKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  DCHECK(g_driver_egl.debug_fn.eglDestroyStreamKHRFn != nullptr);
+  EGLBoolean result = g_driver_egl.debug_fn.eglDestroyStreamKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static EGLBoolean GL_BINDING_CALL Debug_eglDestroySurface(EGLDisplay dpy,
                                                           EGLSurface surface) {
   GL_SERVICE_LOG("eglDestroySurface"
                  << "(" << dpy << ", " << surface << ")");
   DCHECK(g_driver_egl.debug_fn.eglDestroySurfaceFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroySurfaceFn(dpy, surface);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
@@ skipping 202 matching lines @@
   GL_SERVICE_LOG("eglQueryContext"
                  << "(" << dpy << ", " << ctx << ", " << attribute << ", "
                  << static_cast<const void*>(value) << ")");
   DCHECK(g_driver_egl.debug_fn.eglQueryContextFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglQueryContextFn(dpy, ctx, attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
+static EGLBoolean GL_BINDING_CALL Debug_eglQueryStreamKHR(EGLDisplay dpy,
+                                                          EGLStreamKHR stream,
+                                                          EGLenum attribute,
+                                                          EGLint* value) {
+  GL_SERVICE_LOG("eglQueryStreamKHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQueryStreamKHRFn != nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglQueryStreamKHRFn(dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglQueryStreamu64KHR(EGLDisplay dpy,
+                           EGLStreamKHR stream,
+                           EGLenum attribute,
+                           EGLuint64KHR* value) {
+  GL_SERVICE_LOG("eglQueryStreamu64KHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQueryStreamu64KHRFn != nullptr);
+  EGLBoolean result = g_driver_egl.debug_fn.eglQueryStreamu64KHRFn(
+      dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static const char* GL_BINDING_CALL Debug_eglQueryString(EGLDisplay dpy,
                                                         EGLint name) {
   GL_SERVICE_LOG("eglQueryString"
                  << "(" << dpy << ", " << name << ")");
   DCHECK(g_driver_egl.debug_fn.eglQueryStringFn != nullptr);
   const char* result = g_driver_egl.debug_fn.eglQueryStringFn(dpy, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
@@ skipping 41 matching lines @@
 static EGLBoolean GL_BINDING_CALL Debug_eglReleaseThread(void) {
   GL_SERVICE_LOG("eglReleaseThread"
                  << "("
                  << ")");
   DCHECK(g_driver_egl.debug_fn.eglReleaseThreadFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglReleaseThreadFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
+static EGLBoolean GL_BINDING_CALL Debug_eglStreamAttribKHR(EGLDisplay dpy,
+                                                           EGLStreamKHR stream,
+                                                           EGLenum attribute,
+                                                           EGLint value) {
+  GL_SERVICE_LOG("eglStreamAttribKHR"
+                 << "(" << dpy << ", " << stream << ", " << attribute << ", "
+                 << value << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamAttribKHRFn != nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamAttribKHRFn(dpy, stream, attribute, value);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerAcquireKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerAcquireKHRFn != nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamConsumerAcquireKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
+                                                  EGLStreamKHR stream,
+                                                  EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalAttribsNV"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn !=
+         nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn(
+          dpy, stream, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy,
+                                            EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalKHRFn !=
+         nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamConsumerGLTextureExternalKHRFn(dpy,
+                                                                    stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream) {
+  GL_SERVICE_LOG("eglStreamConsumerReleaseKHR"
+                 << "(" << dpy << ", " << stream << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamConsumerReleaseKHRFn != nullptr);
+  EGLBoolean result =
+      g_driver_egl.debug_fn.eglStreamConsumerReleaseKHRFn(dpy, stream);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
+static EGLBoolean GL_BINDING_CALL
+Debug_eglStreamPostD3DTextureNV12ANGLE(EGLDisplay dpy,
+                                       EGLStreamKHR stream,
+                                       void* texture,
+                                       const EGLAttrib* attrib_list) {
+  GL_SERVICE_LOG("eglStreamPostD3DTextureNV12ANGLE"
+                 << "(" << dpy << ", " << stream << ", "
+                 << static_cast<const void*>(texture) << ", "
+                 << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglStreamPostD3DTextureNV12ANGLEFn != nullptr);
+  EGLBoolean result = g_driver_egl.debug_fn.eglStreamPostD3DTextureNV12ANGLEFn(
+      dpy, stream, texture, attrib_list);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static EGLBoolean GL_BINDING_CALL Debug_eglSurfaceAttrib(EGLDisplay dpy,
                                                          EGLSurface surface,
                                                          EGLint attribute,
                                                          EGLint value) {
   GL_SERVICE_LOG("eglSurfaceAttrib"
                  << "(" << dpy << ", " << surface << ", " << attribute << ", "
                  << value << ")");
   DCHECK(g_driver_egl.debug_fn.eglSurfaceAttribFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglSurfaceAttribFn(dpy, surface, attribute, value);
@@ skipping 107 matching lines @@
         Debug_eglCreatePbufferFromClientBuffer;
   }
   if (!debug_fn.eglCreatePbufferSurfaceFn) {
     debug_fn.eglCreatePbufferSurfaceFn = fn.eglCreatePbufferSurfaceFn;
     fn.eglCreatePbufferSurfaceFn = Debug_eglCreatePbufferSurface;
   }
   if (!debug_fn.eglCreatePixmapSurfaceFn) {
     debug_fn.eglCreatePixmapSurfaceFn = fn.eglCreatePixmapSurfaceFn;
     fn.eglCreatePixmapSurfaceFn = Debug_eglCreatePixmapSurface;
   }
+  if (!debug_fn.eglCreateStreamKHRFn) {
+    debug_fn.eglCreateStreamKHRFn = fn.eglCreateStreamKHRFn;
+    fn.eglCreateStreamKHRFn = Debug_eglCreateStreamKHR;
+  }
+  if (!debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn) {
+    debug_fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
+        fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn;
+    fn.eglCreateStreamProducerD3DTextureNV12ANGLEFn =
+        Debug_eglCreateStreamProducerD3DTextureNV12ANGLE;
+  }
   if (!debug_fn.eglCreateSyncKHRFn) {
     debug_fn.eglCreateSyncKHRFn = fn.eglCreateSyncKHRFn;
     fn.eglCreateSyncKHRFn = Debug_eglCreateSyncKHR;
   }
   if (!debug_fn.eglCreateWindowSurfaceFn) {
     debug_fn.eglCreateWindowSurfaceFn = fn.eglCreateWindowSurfaceFn;
     fn.eglCreateWindowSurfaceFn = Debug_eglCreateWindowSurface;
   }
   if (!debug_fn.eglDestroyContextFn) {
     debug_fn.eglDestroyContextFn = fn.eglDestroyContextFn;
     fn.eglDestroyContextFn = Debug_eglDestroyContext;
   }
   if (!debug_fn.eglDestroyImageKHRFn) {
     debug_fn.eglDestroyImageKHRFn = fn.eglDestroyImageKHRFn;
     fn.eglDestroyImageKHRFn = Debug_eglDestroyImageKHR;
   }
+  if (!debug_fn.eglDestroyStreamKHRFn) {
+    debug_fn.eglDestroyStreamKHRFn = fn.eglDestroyStreamKHRFn;
+    fn.eglDestroyStreamKHRFn = Debug_eglDestroyStreamKHR;
+  }
   if (!debug_fn.eglDestroySurfaceFn) {
     debug_fn.eglDestroySurfaceFn = fn.eglDestroySurfaceFn;
     fn.eglDestroySurfaceFn = Debug_eglDestroySurface;
   }
   if (!debug_fn.eglDestroySyncKHRFn) {
     debug_fn.eglDestroySyncKHRFn = fn.eglDestroySyncKHRFn;
     fn.eglDestroySyncKHRFn = Debug_eglDestroySyncKHR;
   }
   if (!debug_fn.eglGetConfigAttribFn) {
     debug_fn.eglGetConfigAttribFn = fn.eglGetConfigAttribFn;
@@ skipping 52 matching lines @@
     fn.eglPostSubBufferNVFn = Debug_eglPostSubBufferNV;
   }
   if (!debug_fn.eglQueryAPIFn) {
     debug_fn.eglQueryAPIFn = fn.eglQueryAPIFn;
     fn.eglQueryAPIFn = Debug_eglQueryAPI;
   }
   if (!debug_fn.eglQueryContextFn) {
     debug_fn.eglQueryContextFn = fn.eglQueryContextFn;
     fn.eglQueryContextFn = Debug_eglQueryContext;
   }
+  if (!debug_fn.eglQueryStreamKHRFn) {
+    debug_fn.eglQueryStreamKHRFn = fn.eglQueryStreamKHRFn;
+    fn.eglQueryStreamKHRFn = Debug_eglQueryStreamKHR;
+  }
+  if (!debug_fn.eglQueryStreamu64KHRFn) {
+    debug_fn.eglQueryStreamu64KHRFn = fn.eglQueryStreamu64KHRFn;
+    fn.eglQueryStreamu64KHRFn = Debug_eglQueryStreamu64KHR;
+  }
   if (!debug_fn.eglQueryStringFn) {
     debug_fn.eglQueryStringFn = fn.eglQueryStringFn;
     fn.eglQueryStringFn = Debug_eglQueryString;
   }
   if (!debug_fn.eglQuerySurfaceFn) {
     debug_fn.eglQuerySurfaceFn = fn.eglQuerySurfaceFn;
     fn.eglQuerySurfaceFn = Debug_eglQuerySurface;
   }
   if (!debug_fn.eglQuerySurfacePointerANGLEFn) {
     debug_fn.eglQuerySurfacePointerANGLEFn = fn.eglQuerySurfacePointerANGLEFn;
     fn.eglQuerySurfacePointerANGLEFn = Debug_eglQuerySurfacePointerANGLE;
   }
   if (!debug_fn.eglReleaseTexImageFn) {
     debug_fn.eglReleaseTexImageFn = fn.eglReleaseTexImageFn;
     fn.eglReleaseTexImageFn = Debug_eglReleaseTexImage;
   }
   if (!debug_fn.eglReleaseThreadFn) {
     debug_fn.eglReleaseThreadFn = fn.eglReleaseThreadFn;
     fn.eglReleaseThreadFn = Debug_eglReleaseThread;
   }
+  if (!debug_fn.eglStreamAttribKHRFn) {
+    debug_fn.eglStreamAttribKHRFn = fn.eglStreamAttribKHRFn;
+    fn.eglStreamAttribKHRFn = Debug_eglStreamAttribKHR;
+  }
+  if (!debug_fn.eglStreamConsumerAcquireKHRFn) {
+    debug_fn.eglStreamConsumerAcquireKHRFn = fn.eglStreamConsumerAcquireKHRFn;
+    fn.eglStreamConsumerAcquireKHRFn = Debug_eglStreamConsumerAcquireKHR;
+  }
+  if (!debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn) {
+    debug_fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
+        fn.eglStreamConsumerGLTextureExternalAttribsNVFn;
+    fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
+        Debug_eglStreamConsumerGLTextureExternalAttribsNV;
+  }
+  if (!debug_fn.eglStreamConsumerGLTextureExternalKHRFn) {
+    debug_fn.eglStreamConsumerGLTextureExternalKHRFn =
+        fn.eglStreamConsumerGLTextureExternalKHRFn;
+    fn.eglStreamConsumerGLTextureExternalKHRFn =
+        Debug_eglStreamConsumerGLTextureExternalKHR;
+  }
+  if (!debug_fn.eglStreamConsumerReleaseKHRFn) {
+    debug_fn.eglStreamConsumerReleaseKHRFn = fn.eglStreamConsumerReleaseKHRFn;
+    fn.eglStreamConsumerReleaseKHRFn = Debug_eglStreamConsumerReleaseKHR;
+  }
+  if (!debug_fn.eglStreamPostD3DTextureNV12ANGLEFn) {
+    debug_fn.eglStreamPostD3DTextureNV12ANGLEFn =
+        fn.eglStreamPostD3DTextureNV12ANGLEFn;
+    fn.eglStreamPostD3DTextureNV12ANGLEFn =
+        Debug_eglStreamPostD3DTextureNV12ANGLE;
+  }
   if (!debug_fn.eglSurfaceAttribFn) {
     debug_fn.eglSurfaceAttribFn = fn.eglSurfaceAttribFn;
     fn.eglSurfaceAttribFn = Debug_eglSurfaceAttrib;
   }
   if (!debug_fn.eglSwapBuffersFn) {
     debug_fn.eglSwapBuffersFn = fn.eglSwapBuffersFn;
     fn.eglSwapBuffersFn = Debug_eglSwapBuffers;
   }
   if (!debug_fn.eglSwapIntervalFn) {
     debug_fn.eglSwapIntervalFn = fn.eglSwapIntervalFn;
@@ skipping 90 matching lines @@
   return driver_->fn.eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
 }
 
 EGLSurface EGLApiBase::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
                                                 EGLConfig config,
                                                 EGLNativePixmapType pixmap,
                                                 const EGLint* attrib_list) {
   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) {
   return driver_->fn.eglCreateSyncKHRFn(dpy, type, attrib_list);
 }
 
 EGLSurface EGLApiBase::eglCreateWindowSurfaceFn(EGLDisplay dpy,
                                                 EGLConfig config,
                                                 EGLNativeWindowType win,
                                                 const EGLint* attrib_list) {
   return driver_->fn.eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
 }
 
 EGLBoolean EGLApiBase::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
   return driver_->fn.eglDestroyContextFn(dpy, ctx);
 }
 
 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);
 }
 
 EGLBoolean EGLApiBase::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
   return driver_->fn.eglDestroySyncKHRFn(dpy, sync);
 }
 
 EGLBoolean EGLApiBase::eglGetConfigAttribFn(EGLDisplay dpy,
                                             EGLConfig config,
@@ skipping 82 matching lines @@
   return driver_->fn.eglQueryAPIFn();
 }
 
 EGLBoolean EGLApiBase::eglQueryContextFn(EGLDisplay dpy,
                                          EGLContext ctx,
                                          EGLint attribute,
                                          EGLint* value) {
   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);
 }
 
 EGLBoolean EGLApiBase::eglQuerySurfaceFn(EGLDisplay dpy,
                                          EGLSurface surface,
                                          EGLint attribute,
                                          EGLint* value) {
   return driver_->fn.eglQuerySurfaceFn(dpy, surface, attribute, value);
 }
 
 EGLBoolean EGLApiBase::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
                                                      EGLSurface surface,
                                                      EGLint attribute,
                                                      void** value) {
   return driver_->fn.eglQuerySurfacePointerANGLEFn(dpy, surface, attribute,
                                                    value);
 }
 
 EGLBoolean EGLApiBase::eglReleaseTexImageFn(EGLDisplay dpy,
                                             EGLSurface surface,
                                             EGLint buffer) {
   return driver_->fn.eglReleaseTexImageFn(dpy, surface, buffer);
 }
 
 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,
                                           EGLint value) {
   return driver_->fn.eglSurfaceAttribFn(dpy, surface, attribute, value);
 }
 
 EGLBoolean EGLApiBase::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
   return driver_->fn.eglSwapBuffersFn(dpy, surface);
 }
@@ skipping 98 matching lines @@
 }
 
 EGLSurface TraceEGLApi::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
                                                  EGLConfig config,
                                                  EGLNativePixmapType pixmap,
                                                  const EGLint* attrib_list) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreatePixmapSurface")
   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) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreateSyncKHR")
   return egl_api_->eglCreateSyncKHRFn(dpy, type, attrib_list);
 }
 
 EGLSurface TraceEGLApi::eglCreateWindowSurfaceFn(EGLDisplay dpy,
                                                  EGLConfig config,
                                                  EGLNativeWindowType win,
                                                  const EGLint* attrib_list) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreateWindowSurface")
   return egl_api_->eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
 }
 
 EGLBoolean TraceEGLApi::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroyContext")
   return egl_api_->eglDestroyContextFn(dpy, ctx);
 }
 
 EGLBoolean TraceEGLApi::eglDestroyImageKHRFn(EGLDisplay dpy,
                                              EGLImageKHR image) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroyImageKHR")
   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")
   return egl_api_->eglDestroySurfaceFn(dpy, surface);
 }
 
 EGLBoolean TraceEGLApi::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroySyncKHR")
   return egl_api_->eglDestroySyncKHRFn(dpy, sync);
 }
@@ skipping 101 matching lines @@
 }
 
 EGLBoolean TraceEGLApi::eglQueryContextFn(EGLDisplay dpy,
                                           EGLContext ctx,
                                           EGLint attribute,
                                           EGLint* value) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryContext")
   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);
 }
 
 EGLBoolean TraceEGLApi::eglQuerySurfaceFn(EGLDisplay dpy,
                                           EGLSurface surface,
                                           EGLint attribute,
                                           EGLint* value) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQuerySurface")
@@ skipping 15 matching lines @@
                                              EGLint buffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglReleaseTexImage")
   return egl_api_->eglReleaseTexImageFn(dpy, surface, buffer);
 }
 
 EGLBoolean TraceEGLApi::eglReleaseThreadFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglReleaseThread")
   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,
                                            EGLint value) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglSurfaceAttrib")
   return egl_api_->eglSurfaceAttribFn(dpy, surface, attribute, value);
 }
 
 EGLBoolean TraceEGLApi::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglSwapBuffers")
@@ skipping 26 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