Support swap damage rect using eglSwapBuffersWithDamageKHR

ui/gl/gl_bindings_autogen_egl.cc

 // Copyright 2016 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 91 matching lines @@
   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.eglSwapBuffersWithDamageKHRFn = 0;
   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"));
@@ skipping 43 matching lines @@
   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_swap_buffers_with_damage =
+      extensions.find("EGL_KHR_swap_buffers_with_damage ") != 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;
@@ skipping 103 matching lines @@
             GetGLProcAddress("eglStreamConsumerReleaseKHR"));
   }
 
   debug_fn.eglStreamPostD3DTextureNV12ANGLEFn = 0;
   if (ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12) {
     fn.eglStreamPostD3DTextureNV12ANGLEFn =
         reinterpret_cast<eglStreamPostD3DTextureNV12ANGLEProc>(
             GetGLProcAddress("eglStreamPostD3DTextureNV12ANGLE"));
   }
 
+  debug_fn.eglSwapBuffersWithDamageKHRFn = 0;
+  if (ext.b_EGL_KHR_swap_buffers_with_damage) {
+    fn.eglSwapBuffersWithDamageKHRFn =
+        reinterpret_cast<eglSwapBuffersWithDamageKHRProc>(
+            GetGLProcAddress("eglSwapBuffersWithDamageKHR"));
+  }
+
   debug_fn.eglWaitSyncKHRFn = 0;
   if (ext.b_EGL_KHR_wait_sync) {
     fn.eglWaitSyncKHRFn = reinterpret_cast<eglWaitSyncKHRProc>(
         GetGLProcAddress("eglWaitSyncKHR"));
   }
 
   if (g_debugBindingsInitialized)
     InitializeDebugBindings();
 }
 
@@ skipping 655 matching lines @@
 static EGLBoolean GL_BINDING_CALL Debug_eglSwapBuffers(EGLDisplay dpy,
                                                        EGLSurface surface) {
   GL_SERVICE_LOG("eglSwapBuffers"
                  << "(" << dpy << ", " << surface << ")");
   DCHECK(g_driver_egl.debug_fn.eglSwapBuffersFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglSwapBuffersFn(dpy, surface);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
+static EGLBoolean GL_BINDING_CALL
+Debug_eglSwapBuffersWithDamageKHR(EGLDisplay dpy,
+                                  EGLSurface surface,
+                                  EGLint* rects,
+                                  EGLint n_rects) {
+  GL_SERVICE_LOG("eglSwapBuffersWithDamageKHR"
+                 << "(" << dpy << ", " << surface << ", "
+                 << static_cast<const void*>(rects) << ", " << n_rects << ")");
+  DCHECK(g_driver_egl.debug_fn.eglSwapBuffersWithDamageKHRFn != nullptr);
+  EGLBoolean result = g_driver_egl.debug_fn.eglSwapBuffersWithDamageKHRFn(
+      dpy, surface, rects, n_rects);
+  GL_SERVICE_LOG("GL_RESULT: " << result);
+  return result;
+}
+
 static EGLBoolean GL_BINDING_CALL Debug_eglSwapInterval(EGLDisplay dpy,
                                                         EGLint interval) {
   GL_SERVICE_LOG("eglSwapInterval"
                  << "(" << dpy << ", " << interval << ")");
   DCHECK(g_driver_egl.debug_fn.eglSwapIntervalFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglSwapIntervalFn(dpy, interval);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
@@ skipping 255 matching lines @@
         Debug_eglStreamPostD3DTextureNV12ANGLE;
   }
   if (!debug_fn.eglSurfaceAttribFn) {
     debug_fn.eglSurfaceAttribFn = fn.eglSurfaceAttribFn;
     fn.eglSurfaceAttribFn = Debug_eglSurfaceAttrib;
   }
   if (!debug_fn.eglSwapBuffersFn) {
     debug_fn.eglSwapBuffersFn = fn.eglSwapBuffersFn;
     fn.eglSwapBuffersFn = Debug_eglSwapBuffers;
   }
+  if (!debug_fn.eglSwapBuffersWithDamageKHRFn) {
+    debug_fn.eglSwapBuffersWithDamageKHRFn = fn.eglSwapBuffersWithDamageKHRFn;
+    fn.eglSwapBuffersWithDamageKHRFn = Debug_eglSwapBuffersWithDamageKHR;
+  }
   if (!debug_fn.eglSwapIntervalFn) {
     debug_fn.eglSwapIntervalFn = fn.eglSwapIntervalFn;
     fn.eglSwapIntervalFn = Debug_eglSwapInterval;
   }
   if (!debug_fn.eglTerminateFn) {
     debug_fn.eglTerminateFn = fn.eglTerminateFn;
     fn.eglTerminateFn = Debug_eglTerminate;
   }
   if (!debug_fn.eglWaitClientFn) {
     debug_fn.eglWaitClientFn = fn.eglWaitClientFn;
@@ skipping 324 matching lines @@
                                           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);
 }
 
+EGLBoolean EGLApiBase::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
+                                                     EGLSurface surface,
+                                                     EGLint* rects,
+                                                     EGLint n_rects) {
+  return driver_->fn.eglSwapBuffersWithDamageKHRFn(dpy, surface, rects,
+                                                   n_rects);
+}
+
 EGLBoolean EGLApiBase::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
   return driver_->fn.eglSwapIntervalFn(dpy, interval);
 }
 
 EGLBoolean EGLApiBase::eglTerminateFn(EGLDisplay dpy) {
   return driver_->fn.eglTerminateFn(dpy);
 }
 
 EGLBoolean EGLApiBase::eglWaitClientFn(void) {
   return driver_->fn.eglWaitClientFn();
@@ skipping 379 matching lines @@
                                            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")
   return egl_api_->eglSwapBuffersFn(dpy, surface);
 }
 
+EGLBoolean TraceEGLApi::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
+                                                      EGLSurface surface,
+                                                      EGLint* rects,
+                                                      EGLint n_rects) {
+  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+                                "TraceGLAPI::eglSwapBuffersWithDamageKHR")
+  return egl_api_->eglSwapBuffersWithDamageKHRFn(dpy, surface, rects, n_rects);
+}
+
 EGLBoolean TraceEGLApi::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglSwapInterval")
   return egl_api_->eglSwapIntervalFn(dpy, interval);
 }
 
 EGLBoolean TraceEGLApi::eglTerminateFn(EGLDisplay dpy) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglTerminate")
   return egl_api_->eglTerminateFn(dpy);
 }
 
@@ skipping 13 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 gl