Support EGL_KHR_swap_buffers_with_damage in the EGL backend.

src/libANGLE/Caps.cpp

@@ -1351,7 +1351,7 @@ std::vector<std::string> DisplayExtensions::getStrings() const
     InsertExtensionString("EGL_ANGLE_create_context_webgl_compatibility",        createContextWebGLCompatibility,    &extensionStrings);
     InsertExtensionString("EGL_CHROMIUM_create_context_bind_generates_resource", createContextBindGeneratesResource, &extensionStrings);
     InsertExtensionString("EGL_CHROMIUM_sync_control",                           getSyncValues,                      &extensionStrings);
-    InsertExtensionString("EGL_EXT_swap_buffers_with_damage",                    swapBuffersWithDamage,              &extensionStrings);
+    InsertExtensionString("EGL_KHR_swap_buffers_with_damage",                    swapBuffersWithDamage,              &extensionStrings);
     InsertExtensionString("EGL_EXT_pixel_format_float",                          pixelFormatFloat,                   &extensionStrings);
     InsertExtensionString("EGL_KHR_surfaceless_context",                         surfacelessContext,                 &extensionStrings);
     InsertExtensionString("EGL_ANGLE_display_texture_share_group",               displayTextureShareGroup,           &extensionStrings);

src/libANGLE/Caps.h

@@ -744,7 +744,7 @@ struct DisplayExtensions
     // EGL_CHROMIUM_get_sync_values
     bool getSyncValues;
 
-    // EGL_EXT_swap_buffers_with_damage
+    // EGL_KHR_swap_buffers_with_damage
     bool swapBuffersWithDamage;
 
     // EGL_EXT_pixel_format_float

src/libANGLE/renderer/gl/egl/DisplayEGL.cpp

@@ -104,6 +104,7 @@ void DisplayEGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
         mEGL->hasExtension("EGL_EXT_create_context_robustness");
 
     outExtensions->postSubBuffer = false;  // Since SurfaceEGL::postSubBuffer is not implemented
+    outExtensions->swapBuffersWithDamage = mEGL->hasExtension("EGL_KHR_swap_buffers_with_damage");
 
     // Contexts are virtualized so textures can be shared globally
     outExtensions->displayTextureShareGroup = true;

src/libANGLE/renderer/gl/egl/FunctionsEGL.cpp

@@ -62,7 +62,9 @@ struct FunctionsEGL::EGLDispatchTable
           clientWaitSyncKHRPtr(nullptr),
           createSyncKHRPtr(nullptr),
           destroySyncKHRPtr(nullptr),
-          getSyncAttribKHRPtr(nullptr)
+          getSyncAttribKHRPtr(nullptr),
+
+          swapBuffersWithDamageKHRPtr(nullptr)
     {
     }
 
@@ -98,6 +100,9 @@ struct FunctionsEGL::EGLDispatchTable
     PFNEGLCREATESYNCKHRPROC createSyncKHRPtr;
     PFNEGLDESTROYSYNCKHRPROC destroySyncKHRPtr;
     PFNEGLGETSYNCATTRIBKHRPROC getSyncAttribKHRPtr;
+
+    // EGL_KHR_swap_buffers_with_damage
+    PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC swapBuffersWithDamageKHRPtr;
 };
 
 FunctionsEGL::FunctionsEGL()
@@ -177,6 +182,11 @@ egl::Error FunctionsEGL::initialize(EGLNativeDisplayType nativeDisplay)
         ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->getSyncAttribKHRPtr, eglGetSyncAttribKHR);
     }
 
+    if (hasExtension("EGL_KHR_swap_buffers_with_damage"))
+    {
+        ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->swapBuffersWithDamageKHRPtr, eglSwapBuffersWithDamageKHR);
+    }
+
 #undef ANGLE_GET_PROC_OR_ERROR
 
     return egl::NoError();
@@ -337,4 +347,11 @@ EGLBoolean FunctionsEGL::getSyncAttribKHR(EGLSyncKHR sync, EGLint attribute, EGL
 {
     return mFnPtrs->getSyncAttribKHRPtr(mEGLDisplay, sync, attribute, value);
 }
+
+EGLBoolean FunctionsEGL::swapBuffersWithDamageKHR(EGLSurface surface,
+                                                  EGLint *rects,
+                                                  EGLint n_rects) const
+{
+    return mFnPtrs->swapBuffersWithDamageKHRPtr(mEGLDisplay, surface, rects, n_rects);
+}
 }  // namespace rx

src/libANGLE/renderer/gl/egl/FunctionsEGL.h

@@ -75,6 +75,8 @@ class FunctionsEGL
     EGLint clientWaitSyncKHR(EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
     EGLBoolean getSyncAttribKHR(EGLSyncKHR sync, EGLint attribute, EGLint *value);
 
+    EGLBoolean swapBuffersWithDamageKHR(EGLSurface surface, EGLint *rects, EGLint n_rects) const;
+
   private:
     // So as to isolate from angle we do not include angleutils.h and cannot
     // use angle::NonCopyable so we replicated it here instead.

src/libANGLE/renderer/gl/egl/SurfaceEGL.cpp

@@ -43,6 +43,16 @@ egl::Error SurfaceEGL::swap(const gl::Context *context)
     return egl::NoError();
 }
 
+egl::Error SurfaceEGL::swapWithDamage(const gl::Context *context, EGLint *rects, EGLint n_rects)
+{
+    EGLBoolean success = mEGL->swapBuffersWithDamageKHR(mSurface, rects, n_rects);
+    if (success == EGL_FALSE)
+    {
+        return egl::Error(mEGL->getError(), "eglSwapBuffersWithDamageKHR failed");
+    }
+    return egl::NoError();
+}
+
 egl::Error SurfaceEGL::postSubBuffer(const gl::Context *context,
                                      EGLint x,
                                      EGLint y,

src/libANGLE/renderer/gl/egl/SurfaceEGL.h

@@ -25,6 +25,7 @@ class SurfaceEGL : public SurfaceGL
 
     egl::Error makeCurrent() override;
     egl::Error swap(const gl::Context *context) override;
+    egl::Error swapWithDamage(const gl::Context *context, EGLint *rects, EGLint n_rects) override;
     egl::Error postSubBuffer(const gl::Context *context,
                              EGLint x,
                              EGLint y,

src/libANGLE/validationEGL.cpp

@@ -2255,7 +2255,7 @@ Error ValidateGetSyncValuesCHROMIUM(const Display *display,
     return NoError();
 }
 
-Error ValidateSwapBuffersWithDamageEXT(const Display *display,
+Error ValidateSwapBuffersWithDamageKHR(const Display *display,
                                        const Surface *surface,
                                        EGLint *rects,
                                        EGLint n_rects)
@@ -2270,7 +2270,7 @@ Error ValidateSwapBuffersWithDamageEXT(const Display *display,
     {
         // It is out of spec what happens when calling an extension function when the extension is
         // not available. EGL_BAD_DISPLAY seems like a reasonable error.
-        return EglBadDisplay() << "EGL_EXT_swap_buffers_with_damage is not available.";
+        return EglBadDisplay() << "EGL_KHR_swap_buffers_with_damage is not available.";
     }
 
     if (surface == EGL_NO_SURFACE)

src/libANGLE/validationEGL.h

@@ -104,7 +104,7 @@ Error ValidateGetSyncValuesCHROMIUM(const Display *display,
                                     const EGLuint64KHR *msc,
                                     const EGLuint64KHR *sbc);
 
-Error ValidateSwapBuffersWithDamageEXT(const Display *display,
+Error ValidateSwapBuffersWithDamageKHR(const Display *display,
                                        const Surface *surface,
                                        EGLint *rects,
                                        EGLint n_rects);

src/libEGL/libEGL.cpp

@@ -368,12 +368,12 @@ EGLBoolean EGLAPIENTRY eglGetSyncValuesCHROMIUM(EGLDisplay dpy,
     return egl::GetSyncValuesCHROMIUM(dpy, surface, ust, msc, sbc);
 }
 
-EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageEXT(EGLDisplay dpy,
+EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageKHR(EGLDisplay dpy,
                                                    EGLSurface surface,
                                                    EGLint *rects,
                                                    EGLint n_rects)
 {
-    return egl::SwapBuffersWithDamageEXT(dpy, surface, rects, n_rects);
+    return egl::SwapBuffersWithDamageKHR(dpy, surface, rects, n_rects);
 }
 
 EGLint EGLAPIENTRY eglProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib)

src/libEGL/libEGL.def

@@ -58,7 +58,7 @@ EXPORTS
     eglCreateStreamProducerD3DTextureANGLE      @64
     eglStreamPostD3DTextureANGLE                @65
     eglGetSyncValuesCHROMIUM                    @66
-    eglSwapBuffersWithDamageEXT                 @67
+    eglSwapBuffersWithDamageKHR                 @67
     eglProgramCacheGetAttribANGLE               @68
     eglProgramCachePopulateANGLE                @69
     eglProgramCacheQueryANGLE                   @70

src/libGLESv2/entry_points_egl_ext.cpp

@@ -754,10 +754,10 @@ EGLBoolean EGLAPIENTRY GetSyncValuesCHROMIUM(EGLDisplay dpy,
     return EGL_TRUE;
 }
 
-ANGLE_EXPORT EGLBoolean SwapBuffersWithDamageEXT(EGLDisplay dpy,
-                                                 EGLSurface surface,
-                                                 EGLint *rects,
-                                                 EGLint n_rects)
+EGLBoolean EGLAPIENTRY SwapBuffersWithDamageKHR(EGLDisplay dpy,
+                                                EGLSurface surface,
+                                                EGLint *rects,
+                                                EGLint n_rects)
 {
     EVENT(
         "(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint *rects = 0x%0.8p, EGLint "
@@ -768,7 +768,7 @@ ANGLE_EXPORT EGLBoolean SwapBuffersWithDamageEXT(EGLDisplay dpy,
     Display *display    = static_cast<Display *>(dpy);
     Surface *eglSurface = static_cast<Surface *>(surface);
 
-    Error error = ValidateSwapBuffersWithDamageEXT(display, eglSurface, rects, n_rects);
+    Error error = ValidateSwapBuffersWithDamageKHR(display, eglSurface, rects, n_rects);
     if (error.isError())
     {
         thread->setError(error);

src/libGLESv2/entry_points_egl_ext.h

@@ -87,11 +87,11 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY GetSyncValuesCHROMIUM(EGLDisplay dpy,
                                                           EGLuint64KHR *msc,
                                                           EGLuint64KHR *sbc);
 
-// EGL_EXT_swap_buffers_with_damage
-ANGLE_EXPORT EGLBoolean SwapBuffersWithDamageEXT(EGLDisplay dpy,
-                                                 EGLSurface surface,
-                                                 EGLint *rects,
-                                                 EGLint n_rects);
+// EGL_KHR_swap_buffers_with_damage
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY SwapBuffersWithDamageKHR(EGLDisplay dpy,
+                                                             EGLSurface surface,
+                                                             EGLint *rects,
+                                                             EGLint n_rects);
 
 //
 ANGLE_EXPORT EGLint EGLAPIENTRY ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib);

src/libGLESv2/proc_table_autogen.cpp

@@ -92,7 +92,7 @@ ProcEntry g_procTable[] = {
     {"eglStreamPostD3DTextureANGLE", P(egl::StreamPostD3DTextureANGLE)},
     {"eglSurfaceAttrib", P(egl::SurfaceAttrib)},
     {"eglSwapBuffers", P(egl::SwapBuffers)},
-    {"eglSwapBuffersWithDamageEXT", P(egl::SwapBuffersWithDamageEXT)},
+    {"eglSwapBuffersWithDamageKHR", P(egl::SwapBuffersWithDamageKHR)},
     {"eglSwapInterval", P(egl::SwapInterval)},
     {"eglTerminate", P(egl::Terminate)},
     {"eglWaitClient", P(egl::WaitClient)},

src/libGLESv2/proc_table_data.json

@@ -822,8 +822,8 @@
         "eglGetSyncValuesCHROMIUM"
     ],
 
-    "EGL_EXT_swap_buffers_with_damage": [
-        "eglSwapBuffersWithDamageEXT"
+    "EGL_KHR_swap_buffers_with_damage": [
+        "eglSwapBuffersWithDamageKHR"
     ],
 
     "EGL_ANGLE_program_cache_control": [