Implement GL_ARB_create_context_robustness on GLX and WGL

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -282,8 +282,7 @@ void ContextGL::stencilThenCoverStrokePathInstanced(const std::vector<gl::Path *
 
 GLenum ContextGL::getResetStatus()
 {
-    UNIMPLEMENTED();
-    return GL_NO_ERROR;
+    return mRenderer->getResetStatus();
 }
 
 std::string ContextGL::getVendorString() const

src/libANGLE/renderer/gl/FunctionsGL.cpp

@@ -1023,6 +1023,12 @@ void FunctionsGL::initializeProcsDesktopGL()
     AssignGLExtensionEntryPoint(extensions, "GL_ARB_get_program_binary", loadProcAddress("glProgramBinary"), &programBinary);
     AssignGLExtensionEntryPoint(extensions, "GL_ARB_get_program_binary", loadProcAddress("glProgramParameteri"), &programParameteri);
 
+    // GL_ARB_robustness
+    AssignGLExtensionEntryPoint(extensions, "GL_ARB_robustness", loadProcAddress("glGetGraphicsResetStatusARB"), &getGraphicsResetStatus);
+
+    // GL_KHR_robustness
+    AssignGLExtensionEntryPoint(extensions, "GL_KHR_robustness", loadProcAddress("glGetGraphicsResetStatus"), &getGraphicsResetStatus);
+
     // 1.0
     if (isAtLeastGL(gl::Version(1, 0)))
     {
@@ -1885,6 +1891,12 @@ void FunctionsGL::initializeProcsGLES()
     AssignGLExtensionEntryPoint(extensions, "GL_OES_get_program_binary", loadProcAddress("glGetProgramBinaryOES"), &getProgramBinary);
     AssignGLExtensionEntryPoint(extensions, "GL_OES_get_program_binary", loadProcAddress("glProgramBinaryOES"), &programBinary);
 
+    // GL_EXT_robustness
+    AssignGLExtensionEntryPoint(extensions, "GL_EXT_robustness", loadProcAddress("glGetGraphicsResetStatusEXT"), &getGraphicsResetStatus);
+
+    // GL_KHR_robustness
+    AssignGLExtensionEntryPoint(extensions, "GL_KHR_robustness", loadProcAddress("glGetGraphicsResetStatusKHR"), &getGraphicsResetStatus);
+
     // 2.0
     if (isAtLeastGLES(gl::Version(2, 0)))
     {

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -425,6 +425,11 @@ void RendererGL::stencilThenCoverStrokePathInstanced(const gl::ContextState &sta
     ASSERT(mFunctions->getError() == GL_NO_ERROR);
 }
 
+GLenum RendererGL::getResetStatus()
+{
+    return mFunctions->getGraphicsResetStatus();
+}
+
 ContextImpl *RendererGL::createContext(const gl::ContextState &state)
 {
     return new ContextGL(state, this);

src/libANGLE/renderer/gl/RendererGL.h

@@ -137,6 +137,8 @@ class RendererGL : angle::NonCopyable
                                              GLenum transformType,
                                              const GLfloat *transformValues);
 
+    GLenum getResetStatus();
+
     // EXT_debug_marker
     void insertEventMarker(GLsizei length, const char *marker);
     void pushGroupMarker(GLsizei length, const char *marker);

src/libANGLE/renderer/gl/glx/DisplayGLX.cpp

@@ -19,6 +19,7 @@
 #include "libANGLE/Surface.h"
 #include "libANGLE/renderer/gl/glx/PbufferSurfaceGLX.h"
 #include "libANGLE/renderer/gl/glx/WindowSurfaceGLX.h"
+#include "libANGLE/renderer/gl/RendererGL.h"
 #include "libANGLE/renderer/gl/renderergl_utils.h"
 #include "third_party/libXNVCtrl/NVCtrl.h"
 #include "third_party/libXNVCtrl/NVCtrlLib.h"
@@ -117,6 +118,7 @@ DisplayGLX::DisplayGLX()
       mHasMultisample(false),
       mHasARBCreateContext(false),
       mHasARBCreateContextProfile(false),
+      mHasARBCreateContextRobustness(false),
       mHasEXTCreateContextES2Profile(false),
       mSwapControl(SwapControl::Absent),
       mMinSwapInterval(0),
@@ -159,6 +161,7 @@ egl::Error DisplayGLX::initialize(egl::Display *display)
     mHasMultisample      = mGLX.minorVersion > 3 || mGLX.hasExtension("GLX_ARB_multisample");
     mHasARBCreateContext = mGLX.hasExtension("GLX_ARB_create_context");
     mHasARBCreateContextProfile    = mGLX.hasExtension("GLX_ARB_create_context_profile");
+    mHasARBCreateContextRobustness = mGLX.hasExtension("GLX_ARB_create_context_robustness");
     mHasEXTCreateContextES2Profile = mGLX.hasExtension("GLX_EXT_create_context_es2_profile");
 
     std::string clientVendor = mGLX.getClientString(GLX_VENDOR);
@@ -386,7 +389,7 @@ SurfaceImpl *DisplayGLX::createWindowSurface(const egl::SurfaceState &state,
     ASSERT(configIdToGLXConfig.count(configuration->configID) > 0);
     glx::FBConfig fbConfig = configIdToGLXConfig[configuration->configID];
 
-    return new WindowSurfaceGLX(state, mGLX, this, this->getRenderer(), window, mGLX.getDisplay(),
+    return new WindowSurfaceGLX(state, mGLX, this, getRenderer(), window, mGLX.getDisplay(),
                                 mContext, fbConfig);
 }
 
@@ -401,7 +404,7 @@ SurfaceImpl *DisplayGLX::createPbufferSurface(const egl::SurfaceState &state,
     EGLint height = static_cast<EGLint>(attribs.get(EGL_HEIGHT, 0));
     bool largest = (attribs.get(EGL_LARGEST_PBUFFER, EGL_FALSE) == EGL_TRUE);
 
-    return new PbufferSurfaceGLX(state, this->getRenderer(), width, height, largest, mGLX, mContext,
+    return new PbufferSurfaceGLX(state, getRenderer(), width, height, largest, mGLX, mContext,
                                  fbConfig);
 }
 
@@ -727,13 +730,16 @@ egl::ConfigSet DisplayGLX::generateConfigs()
 
 bool DisplayGLX::testDeviceLost()
 {
-    // UNIMPLEMENTED();
+    if (mHasARBCreateContextRobustness)
+    {
+        return getRenderer()->getResetStatus() != GL_NO_ERROR;
+    }
+
     return false;
 }
 
 egl::Error DisplayGLX::restoreLostDevice()
 {
-    UNIMPLEMENTED();
     return egl::Error(EGL_BAD_DISPLAY);
 }
 
@@ -885,11 +891,11 @@ const FunctionsGL *DisplayGLX::getFunctionsGL() const
 
 void DisplayGLX::generateExtensions(egl::DisplayExtensions *outExtensions) const
 {
+    outExtensions->createContextRobustness = mHasARBCreateContextRobustness;
 }
 
 void DisplayGLX::generateCaps(egl::Caps *outCaps) const
 {
-    // UNIMPLEMENTED();
     outCaps->textureNPOT = true;
 }
 
@@ -907,6 +913,12 @@ egl::Error DisplayGLX::createContextAttribs(glx::FBConfig,
 {
     std::vector<int> attribs;
 
+    if (mHasARBCreateContextRobustness)
+    {
+        attribs.push_back(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB);
+        attribs.push_back(GLX_LOSE_CONTEXT_ON_RESET_ARB);
+    }
+
     if (version.valid())
     {
         attribs.push_back(GLX_CONTEXT_MAJOR_VERSION_ARB);

src/libANGLE/renderer/gl/glx/DisplayGLX.h

@@ -125,6 +125,7 @@ class DisplayGLX : public DisplayGL
     bool mHasMultisample;
     bool mHasARBCreateContext;
     bool mHasARBCreateContextProfile;
+    bool mHasARBCreateContextRobustness;
     bool mHasEXTCreateContextES2Profile;
 
     enum class SwapControl

src/libANGLE/renderer/gl/glx/platform_glx.h

@@ -116,6 +116,12 @@
 #define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
 #define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
 
+// GLX_ARB_create_context_robustness
+#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define GLX_NO_RESET_NOTIFICATION_ARB 0x8261
+
 // GLX_EXT_create_context_es2_profile
 #define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
 

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -847,6 +847,12 @@ void GenerateCaps(const FunctionsGL *functions, gl::Caps *caps, gl::TextureCapsM
         functions->hasGLExtension("GL_NV_framebuffer_mixed_samples") ||
         functions->hasGLESExtension("GL_NV_framebuffer_mixed_samples");
 
+    extensions->robustness = functions->isAtLeastGL(gl::Version(4, 5)) ||
+                             functions->hasGLExtension("GL_KHR_robustness") ||
+                             functions->hasGLExtension("GL_ARB_robustness") ||
+                             functions->isAtLeastGLES(gl::Version(3, 2)) ||
+                             functions->hasGLESExtension("GL_KHR_robustness") ||
+                             functions->hasGLESExtension("GL_EXT_robustness");
 
     // NV_path_rendering
     // We also need interface query which is available in

src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp

@@ -12,6 +12,7 @@
 #include "libANGLE/Config.h"
 #include "libANGLE/Display.h"
 #include "libANGLE/Surface.h"
+#include "libANGLE/renderer/gl/RendererGL.h"
 #include "libANGLE/renderer/gl/renderergl_utils.h"
 #include "libANGLE/renderer/gl/wgl/DXGISwapChainWindowSurfaceWGL.h"
 #include "libANGLE/renderer/gl/wgl/FunctionsWGL.h"
@@ -59,6 +60,7 @@ DisplayWGL::DisplayWGL()
       mOpenGLModule(nullptr),
       mFunctionsWGL(nullptr),
       mFunctionsGL(nullptr),
+      mHasARBCreateContextRobustness(false),
       mWindowClass(0),
       mWindow(nullptr),
       mDeviceContext(nullptr),
@@ -173,6 +175,9 @@ egl::Error DisplayWGL::initialize(egl::Display *display)
     // Reinitialize the wgl functions to grab the extensions
     mFunctionsWGL->initialize(mOpenGLModule, dummyDeviceContext);
 
+    mHasARBCreateContextRobustness =
+        mFunctionsWGL->hasExtension("WGL_ARB_create_context_robustness");
+
     // Destroy the dummy window and context
     mFunctionsWGL->makeCurrent(dummyDeviceContext, nullptr);
     mFunctionsWGL->deleteContext(dummyWGLContext);
@@ -259,6 +264,12 @@ egl::Error DisplayWGL::initialize(egl::Display *display)
 
         std::vector<int> contextCreationAttributes;
 
+        if (mHasARBCreateContextRobustness)
+        {
+            contextCreationAttributes.push_back(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB);
+            contextCreationAttributes.push_back(WGL_LOSE_CONTEXT_ON_RESET_ARB);
+        }
+
         // Don't request a specific version unless the user wants one.  WGL will return the highest version
         // that the driver supports if no version is requested.
         EGLint requestedMajorVersion = static_cast<EGLint>(
@@ -416,13 +427,13 @@ SurfaceImpl *DisplayWGL::createWindowSurface(const egl::SurfaceState &state,
     EGLint orientation = static_cast<EGLint>(attribs.get(EGL_SURFACE_ORIENTATION_ANGLE, 0));
     if (mUseDXGISwapChains)
     {
-        return new DXGISwapChainWindowSurfaceWGL(state, this->getRenderer(), window, mD3D11Device,
+        return new DXGISwapChainWindowSurfaceWGL(state, getRenderer(), window, mD3D11Device,
                                                  mD3D11DeviceHandle, mWGLContext, mDeviceContext,
                                                  mFunctionsGL, mFunctionsWGL, orientation);
     }
     else
     {
-        return new WindowSurfaceWGL(state, this->getRenderer(), window, mPixelFormat, mWGLContext,
+        return new WindowSurfaceWGL(state, getRenderer(), window, mPixelFormat, mWGLContext,
                                     mFunctionsWGL, orientation);
     }
 }
@@ -437,9 +448,8 @@ SurfaceImpl *DisplayWGL::createPbufferSurface(const egl::SurfaceState &state,
     EGLenum textureFormat = static_cast<EGLenum>(attribs.get(EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE));
     EGLenum textureTarget = static_cast<EGLenum>(attribs.get(EGL_TEXTURE_TARGET, EGL_NO_TEXTURE));
 
-    return new PbufferSurfaceWGL(state, this->getRenderer(), width, height, textureFormat,
-                                 textureTarget, largest, mPixelFormat, mDeviceContext, mWGLContext,
-                                 mFunctionsWGL);
+    return new PbufferSurfaceWGL(state, getRenderer(), width, height, textureFormat, textureTarget,
+                                 largest, mPixelFormat, mDeviceContext, mWGLContext, mFunctionsWGL);
 }
 
 SurfaceImpl *DisplayWGL::createPbufferFromClientBuffer(const egl::SurfaceState &state,
@@ -543,13 +553,16 @@ egl::ConfigSet DisplayWGL::generateConfigs()
 
 bool DisplayWGL::testDeviceLost()
 {
-    //UNIMPLEMENTED();
+    if (mHasARBCreateContextRobustness)
+    {
+        return getRenderer()->getResetStatus() != GL_NO_ERROR;
+    }
+
     return false;
 }
 
 egl::Error DisplayWGL::restoreLostDevice()
 {
-    UNIMPLEMENTED();
     return egl::Error(EGL_BAD_DISPLAY);
 }
 
@@ -619,6 +632,8 @@ void DisplayWGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
     // prefer to swap with inverted Y.
     outExtensions->postSubBuffer      = mUseDXGISwapChains;
     outExtensions->surfaceOrientation = mUseDXGISwapChains;
+
+    outExtensions->createContextRobustness = mHasARBCreateContextRobustness;
 }
 
 void DisplayWGL::generateCaps(egl::Caps *outCaps) const

src/libANGLE/renderer/gl/wgl/DisplayWGL.h

@@ -78,6 +78,8 @@ class DisplayWGL : public DisplayGL
     FunctionsWGL *mFunctionsWGL;
     FunctionsGL *mFunctionsGL;
 
+    bool mHasARBCreateContextRobustness;
+
     ATOM mWindowClass;
     HWND mWindow;
     HDC mDeviceContext;