Redesign robust resource init as a display extension.

extensions/EGL_ANGLE_create_context_robust_resource_initialization.txt → extensions/EGL_ANGLE_display_robust_resource_initialization.txt

 Name
 
-    EGL_ANGLE_create_context_robust_resource_initialization.txt
+    EGL_ANGLE_display_robust_resource_initialization.txt
 
 Name Strings
 
-    EGL_ANGLE_create_context_robust_resource_initialization
+    EGL_ANGLE_display_robust_resource_initialization
 
 Contributors
 
@@ -35,9 +35,12 @@ Dependencies
     An OpenGL ES implementation supporting ANGLE_robust_resource_initialization
     or an implementation supporting equivalent functionality is required.
 
+    For EGL 1.4 contexts, requires EGL_EXT_client_extensions and
+    EGL_EXT_platform_base, but funtionality is identical.
+
 Overview
 
-    This extension allows creating an OpenGL ES context supporting
+    This extension allows initializing an OpenGL ES Display supporting
     robust resource initialization.
 
 New Types
@@ -51,31 +54,39 @@ New Procedures and Functions
 New Tokens
 
     Accepted as an attribute name in the <*attrib_list> argument to
-    eglCreateContext:
+    eglGetPlatformDisplay:
 
-        EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE    0x320F
+        EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE    0x3453
 
 Additions to the EGL 1.5 Specification
 
     Add a new section entitled "OpenGL ES Robust Resource Initialization"
-    to section 3.7.1:
+    to section 3.2:
 
-    "If the attribute EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE
-    is set to EGL_TRUE, a context supporting <robust resource initialization>
-    will be created. OpenGL ES contexts must support the
-    ANGLE_robust_resource_initialization extension, or equivalent core API
+    "If the attribute EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE
+    is set to EGL_TRUE, a Display supporting <robust resource initialization>
+    will be returned. OpenGL ES contexts created on this display must support
+    the ANGLE_robust_resource_initialization extension, or equivalent core API
     functionality.
-    This attribute is supported only for OpenGL ES contexts. If the
-    implementation does not support robust resource initialization,
-    context creation will fail.
-    The default value of EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE
+    If the implementation does not support robust resource initialization,
+    and EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE is EGL_TRUE,
+    EGL_NO_DISPLAY will be returned.
+    The default value of EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE
     is EGL_FALSE."
 
 Issues
 
-    None
+    (1) Should this be a Display or Context creation extension?
+
+    RESOLVED: Making this a Context creation extension has complications in
+    the implementation - what happens to resources shared between Contexts
+    with and without the extension enabled? Also for display-created resources,
+    such as those used in the D3D11 SwapChain, there's no way to specify if
+    we want them robustly initialized. Hence it is clearer to specify this
+    extension as a Display extension.
 
 Revision History
 
     Version 1, 2015/01/07 - first draft.
     Version 2, 2017/03/01 - renamed extension and enum.
+    Version 3, 2017/05/31 - renamed extension and made into display extension.
\ No newline at end of file

include/EGL/eglext.h

@@ -517,10 +517,10 @@ EGLAPI EGLBoolean EGLAPIENTRY eglPresentationTimeANDROID (EGLDisplay dpy, EGLSur
 #define EGL_RECORDABLE_ANDROID            0x3142
 #endif /* EGL_ANDROID_recordable */
 
-#ifndef EGL_ANGLE_create_context_robust_resource_initialization
-#define EGL_ANGLE_create_context_robust_resource_initialization 1
-#define EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE 0x320F
-#endif /* EGL_ANGLE_create_context_robust_resource_initialization */
+#ifndef EGL_ANGLE_display_robust_resource_initialization
+#define EGL_ANGLE_display_robust_resource_initialization 1
+#define EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE 0x3453
+#endif /* EGL_ANGLE_display_robust_resource_initialization */
 
 #ifndef EGL_ANGLE_d3d_share_handle_client_buffer
 #define EGL_ANGLE_d3d_share_handle_client_buffer 1

include/GLES2/gl2ext.h

@@ -874,7 +874,7 @@ GL_APICALL GLboolean GL_APIENTRY glRequestExtensionANGLE (const GLchar *name);
 
 #ifndef GL_ANGLE_robust_resource_initialization
 #define GL_ANGLE_robust_resource_initialization 1
-#define GL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE 0x93A7
+#define GL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE 0x93AB
 #endif /* GL_ANGLE_robust_resource_initialization */
 
 #ifndef GL_CHROMIUM_framebuffer_mixed_samples

src/libANGLE/Caps.cpp

@@ -1075,8 +1075,7 @@ DisplayExtensions::DisplayExtensions()
       pixelFormatFloat(false),
       surfacelessContext(false),
       displayTextureShareGroup(false),
-      createContextClientArrays(false),
-      createContextRobustResourceInitialization(false)
+      createContextClientArrays(false)
 {
 }
 
@@ -1119,7 +1118,6 @@ std::vector<std::string> DisplayExtensions::getStrings() const
     InsertExtensionString("EGL_KHR_surfaceless_context",                         surfacelessContext,                 &extensionStrings);
     InsertExtensionString("EGL_ANGLE_display_texture_share_group",               displayTextureShareGroup,           &extensionStrings);
     InsertExtensionString("EGL_ANGLE_create_context_client_arrays",              createContextClientArrays,          &extensionStrings);
-    InsertExtensionString("EGL_ANGLE_create_context_robust_resource_initialization", createContextRobustResourceInitialization, &extensionStrings);
     // TODO(jmadill): Enable this when complete.
     //InsertExtensionString("KHR_create_context_no_error",                       createContextNoError,               &extensionStrings);
     // clang-format on
@@ -1154,7 +1152,8 @@ ClientExtensions::ClientExtensions()
       deviceCreationD3D11(false),
       x11Visual(false),
       experimentalPresentPath(false),
-      clientGetAllProcAddresses(false)
+      clientGetAllProcAddresses(false),
+      displayRobustResourceInitialization(false)
 {
 }
 
@@ -1177,9 +1176,10 @@ std::vector<std::string> ClientExtensions::getStrings() const
     InsertExtensionString("EGL_ANGLE_x11_visual",                  x11Visual,                 &extensionStrings);
     InsertExtensionString("EGL_ANGLE_experimental_present_path",   experimentalPresentPath,   &extensionStrings);
     InsertExtensionString("EGL_KHR_client_get_all_proc_addresses", clientGetAllProcAddresses, &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_display_robust_resource_initialization", displayRobustResourceInitialization, &extensionStrings);
     // clang-format on
 
     return extensionStrings;
 }
 
-}
+}  // namespace egl

src/libANGLE/Caps.h

@@ -667,9 +667,6 @@ struct DisplayExtensions
 
     // EGL_ANGLE_create_context_client_arrays
     bool createContextClientArrays;
-
-    // EGL_ANGLE_create_context_robust_resource_initialization
-    bool createContextRobustResourceInitialization;
 };
 
 struct DeviceExtensions
@@ -728,6 +725,9 @@ struct ClientExtensions
 
     // EGL_KHR_client_get_all_proc_addresses
     bool clientGetAllProcAddresses;
+
+    // EGL_ANGLE_display_robust_resource_initialization
+    bool displayRobustResourceInitialization;
 };
 
 }  // namespace egl

src/libANGLE/Context.cpp

@@ -20,6 +20,7 @@
 #include "common/version.h"
 #include "libANGLE/Buffer.h"
 #include "libANGLE/Compiler.h"
+#include "libANGLE/Display.h"
 #include "libANGLE/Fence.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
@@ -203,11 +204,6 @@ bool GetClientArraysEnabled(const egl::AttributeMap &attribs)
     return (attribs.get(EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE, EGL_TRUE) == EGL_TRUE);
 }
 
-bool GetRobustResourceInit(const egl::AttributeMap &attribs)
-{
-    return (attribs.get(EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE, EGL_FALSE) == EGL_TRUE);
-}
-
 std::string GetObjectLabelFromPointer(GLsizei length, const GLchar *label)
 {
     std::string labelName;
@@ -248,7 +244,8 @@ Context::Context(rx::EGLImplFactory *implFactory,
                  const Context *shareContext,
                  TextureManager *shareTextures,
                  const egl::AttributeMap &attribs,
-                 const egl::DisplayExtensions &displayExtensions)
+                 const egl::DisplayExtensions &displayExtensions,
+                 bool robustResourceInit)
 
     : ValidationContext(shareContext,
                         shareTextures,
@@ -284,7 +281,7 @@ Context::Context(rx::EGLImplFactory *implFactory,
 
     mGLState.initialize(mCaps, mExtensions, getClientVersion(), GetDebug(attribs),
                         GetBindGeneratesResource(attribs), GetClientArraysEnabled(attribs),
-                        GetRobustResourceInit(attribs));
+                        robustResourceInit);
 
     mFenceNVHandleAllocator.setBaseHandle(0);
 
@@ -2670,7 +2667,7 @@ void Context::initCaps(const egl::DisplayExtensions &displayExtensions)
 
     // Determine robust resource init availability from EGL.
     mExtensions.robustResourceInitialization =
-        displayExtensions.createContextRobustResourceInitialization;
+        egl::Display::GetClientExtensions().displayRobustResourceInitialization;
 
     // Apply implementation limits
     mCaps.maxVertexAttributes = std::min<GLuint>(mCaps.maxVertexAttributes, MAX_VERTEX_ATTRIBS);

src/libANGLE/Context.h

@@ -64,7 +64,8 @@ class Context final : public ValidationContext
             const Context *shareContext,
             TextureManager *shareTextures,
             const egl::AttributeMap &attribs,
-            const egl::DisplayExtensions &displayExtensions);
+            const egl::DisplayExtensions &displayExtensions,
+            bool robustResourceInit);
 
     void destroy(egl::Display *display);
     ~Context() override;

src/libANGLE/Display.cpp

@@ -268,13 +268,14 @@ void ANGLESetDefaultDisplayPlatform(angle::EGLDisplayType display)
 
 }  // anonymous namespace
 
+// static
 Display *Display::GetDisplayFromNativeDisplay(EGLNativeDisplayType nativeDisplay,
                                               const AttributeMap &attribMap)
 {
     Display *display = nullptr;
 
-    ANGLEPlatformDisplayMap *displays            = GetANGLEPlatformDisplayMap();
-    ANGLEPlatformDisplayMap::const_iterator iter = displays->find(nativeDisplay);
+    ANGLEPlatformDisplayMap *displays = GetANGLEPlatformDisplayMap();
+    const auto &iter                  = displays->find(nativeDisplay);
     if (iter != displays->end())
     {
         display = iter->second;
@@ -308,7 +309,8 @@ Display *Display::GetDisplayFromNativeDisplay(EGLNativeDisplayType nativeDisplay
     return display;
 }
 
-Display *Display::GetDisplayFromDevice(Device *device)
+// static
+Display *Display::GetDisplayFromDevice(Device *device, const AttributeMap &attribMap)
 {
     Display *display = nullptr;
 
@@ -330,7 +332,7 @@ Display *Display::GetDisplayFromDevice(Device *device)
     if (display == nullptr)
     {
         // See if the eglDevice is in use by a Display created using the DEVICE platform
-        DevicePlatformDisplayMap::const_iterator iter = devicePlatformDisplays->find(device);
+        const auto &iter = devicePlatformDisplays->find(device);
         if (iter != devicePlatformDisplays->end())
         {
             display = iter->second;
@@ -348,7 +350,7 @@ Display *Display::GetDisplayFromDevice(Device *device)
     if (!display->isInitialized())
     {
         rx::DisplayImpl *impl = CreateDisplayFromDevice(device, display->getState());
-        display->setAttributes(impl, egl::AttributeMap());
+        display->setAttributes(impl, attribMap);
     }
 
     return display;
@@ -714,8 +716,9 @@ Error Display::createContext(const Config *configuration, gl::Context *shareCont
         shareTextures = mTextureManager;
     }
 
-    gl::Context *context = new gl::Context(mImplementation, configuration, shareContext,
-                                           shareTextures, attribs, mDisplayExtensions);
+    gl::Context *context =
+        new gl::Context(mImplementation, configuration, shareContext, shareTextures, attribs,
+                        mDisplayExtensions, isRobustResourceInitEnabled());
 
     ASSERT(context != nullptr);
     mContextSet.insert(context);
@@ -934,6 +937,9 @@ static ClientExtensions GenerateClientExtensions()
 
     extensions.clientGetAllProcAddresses = true;
 
+    // TODO(jmadill): Not fully implemented yet, but exposed everywhere.
+    extensions.displayRobustResourceInitialization = true;
+
     return extensions;
 }
 
@@ -947,15 +953,18 @@ static std::string GenerateExtensionsString(const T &extensions)
     return stream.str();
 }
 
-const ClientExtensions &Display::getClientExtensions()
+// static
+const ClientExtensions &Display::GetClientExtensions()
 {
     static const ClientExtensions clientExtensions = GenerateClientExtensions();
     return clientExtensions;
 }
 
-const std::string &Display::getClientExtensionString()
+// static
+const std::string &Display::GetClientExtensionString()
 {
-    static const std::string clientExtensionsString = GenerateExtensionsString(getClientExtensions());
+    static const std::string clientExtensionsString =
+        GenerateExtensionsString(GetClientExtensions());
     return clientExtensionsString;
 }
 
@@ -1063,4 +1072,11 @@ gl::Version Display::getMaxSupportedESVersion() const
 {
     return mImplementation->getMaxSupportedESVersion();
 }
+
+bool Display::isRobustResourceInitEnabled() const
+{
+    return (mAttributeMap.get(EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE, EGL_FALSE) ==
+            EGL_TRUE);
+}
+
 }  // namespace egl

src/libANGLE/Display.h

@@ -54,12 +54,12 @@ class Display final : angle::NonCopyable
     Error initialize();
     void terminate();
 
-    static egl::Display *GetDisplayFromDevice(Device *device);
+    static egl::Display *GetDisplayFromDevice(Device *device, const AttributeMap &attribMap);
     static egl::Display *GetDisplayFromNativeDisplay(EGLNativeDisplayType nativeDisplay,
                                                      const AttributeMap &attribMap);
 
-    static const ClientExtensions &getClientExtensions();
-    static const std::string &getClientExtensionString();
+    static const ClientExtensions &GetClientExtensions();
+    static const std::string &GetClientExtensionString();
 
     std::vector<const Config*> getConfigs(const egl::AttributeMap &attribs) const;
 
@@ -133,6 +133,8 @@ class Display final : angle::NonCopyable
 
     const DisplayState &getState() const { return mState; }
 
+    bool isRobustResourceInitEnabled() const;
+
   private:
     Display(EGLenum platform, EGLNativeDisplayType displayId, Device *eglDevice);
 

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -1147,8 +1147,6 @@ void Renderer11::generateDisplayExtensions(egl::DisplayExtensions *outExtensions
     // Contexts are virtualized so textures can be shared globally
     outExtensions->displayTextureShareGroup = true;
 
-    outExtensions->createContextRobustResourceInitialization = true;
-
     // getSyncValues requires direct composition.
     outExtensions->getSyncValues = outExtensions->directComposition;
 }

src/libANGLE/validationEGL.cpp

@@ -275,7 +275,7 @@ Error ValidateGetPlatformDisplayCommon(EGLenum platform,
                                        void *native_display,
                                        const AttributeMap &attribMap)
 {
-    const ClientExtensions &clientExtensions = Display::getClientExtensions();
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
 
     switch (platform)
     {
@@ -308,31 +308,33 @@ Error ValidateGetPlatformDisplayCommon(EGLenum platform,
 
         for (const auto &curAttrib : attribMap)
         {
+            const EGLAttrib value = curAttrib.second;
+
             switch (curAttrib.first)
             {
                 case EGL_PLATFORM_ANGLE_TYPE_ANGLE:
                 {
-                    ANGLE_TRY(ValidatePlatformType(clientExtensions, curAttrib.second));
-                    platformType = curAttrib.second;
+                    ANGLE_TRY(ValidatePlatformType(clientExtensions, value));
+                    platformType = value;
                     break;
                 }
 
                 case EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE:
-                    if (curAttrib.second != EGL_DONT_CARE)
+                    if (value != EGL_DONT_CARE)
                     {
-                        majorVersion = curAttrib.second;
+                        majorVersion = value;
                     }
                     break;
 
                 case EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE:
-                    if (curAttrib.second != EGL_DONT_CARE)
+                    if (value != EGL_DONT_CARE)
                     {
-                        minorVersion = curAttrib.second;
+                        minorVersion = value;
                     }
                     break;
 
                 case EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE:
-                    switch (curAttrib.second)
+                    switch (value)
                     {
                         case EGL_TRUE:
                         case EGL_FALSE:
@@ -350,7 +352,7 @@ Error ValidateGetPlatformDisplayCommon(EGLenum platform,
                                      "EGL_ANGLE_experimental_present_path extension not active");
                     }
 
-                    switch (curAttrib.second)
+                    switch (value)
                     {
                         case EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE:
                         case EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE:
@@ -363,7 +365,7 @@ Error ValidateGetPlatformDisplayCommon(EGLenum platform,
                     break;
 
                 case EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE:
-                    switch (curAttrib.second)
+                    switch (value)
                     {
                         case EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE:
                         case EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE:
@@ -381,7 +383,7 @@ Error ValidateGetPlatformDisplayCommon(EGLenum platform,
                                          "EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE "
                                          "attrib");
                     }
-                    deviceType = curAttrib.second;
+                    deviceType = value;
                     break;
 
                 case EGL_PLATFORM_ANGLE_ENABLE_VALIDATION_LAYER_ANGLE:
@@ -395,13 +397,28 @@ Error ValidateGetPlatformDisplayCommon(EGLenum platform,
                         return Error(EGL_BAD_ATTRIBUTE,
                                      "Validation can only be enabled for the Vulkan back-end.");
                     }
-                    if (curAttrib.second != EGL_TRUE && curAttrib.second != EGL_FALSE)
+                    if (value != EGL_TRUE && value != EGL_FALSE)
                     {
                         return Error(EGL_BAD_ATTRIBUTE,
                                      "Validation layer attribute must be EGL_TRUE or EGL_FALSE.");
                     }
                     break;
 
+                case EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+                    if (!clientExtensions.displayRobustResourceInitialization)
+                    {
+                        return Error(EGL_BAD_ATTRIBUTE,
+                                     "Attribute EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
+                                     "requires EGL_ANGLE_display_robust_resource_initialization.");
+                    }
+                    if (value != EGL_TRUE && value != EGL_FALSE)
+                    {
+                        return Error(EGL_BAD_ATTRIBUTE,
+                                     "EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE must be "
+                                     "either EGL_TRUE or EGL_FALSE.");
+                    }
+                    break;
+
                 default:
                     break;
             }
@@ -710,21 +727,6 @@ Error ValidateCreateContext(Display *display, Config *configuration, gl::Context
               }
               break;
 
-          case EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
-              if (!display->getExtensions().createContextRobustResourceInitialization)
-              {
-                  return Error(EGL_BAD_ATTRIBUTE,
-                               "Attribute EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
-                               "requires EGL_ANGLE_create_context_robust_resource_initialization.");
-              }
-              if (value != EGL_TRUE && value != EGL_FALSE)
-              {
-                  return Error(EGL_BAD_ATTRIBUTE,
-                               "EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE must be "
-                               "either EGL_TRUE or EGL_FALSE.");
-              }
-              break;
-
           default:
               return Error(EGL_BAD_ATTRIBUTE, "Unknown attribute.");
         }
@@ -1533,7 +1535,7 @@ Error ValidateCreateDeviceANGLE(EGLint device_type,
                                 void *native_device,
                                 const EGLAttrib *attrib_list)
 {
-    const ClientExtensions &clientExtensions = Display::getClientExtensions();
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
     if (!clientExtensions.deviceCreation)
     {
         return Error(EGL_BAD_ACCESS, "Device creation extension not active");
@@ -1561,7 +1563,7 @@ Error ValidateCreateDeviceANGLE(EGLint device_type,
 
 Error ValidateReleaseDeviceANGLE(Device *device)
 {
-    const ClientExtensions &clientExtensions = Display::getClientExtensions();
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
     if (!clientExtensions.deviceCreation)
     {
         return Error(EGL_BAD_ACCESS, "Device creation extension not active");

src/libGLESv2/entry_points_egl.cpp

@@ -149,7 +149,7 @@ const char *EGLAPIENTRY QueryString(EGLDisplay dpy, EGLint name)
         case EGL_EXTENSIONS:
             if (display == EGL_NO_DISPLAY)
             {
-                result = Display::getClientExtensionString().c_str();
+                result = Display::GetClientExtensionString().c_str();
             }
             else
             {
@@ -1203,16 +1203,16 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplay(EGLenum platform,
         return EGL_NO_DISPLAY;
     }
 
+    const auto &attribMap = AttributeMap::CreateFromAttribArray(attrib_list);
     if (platform == EGL_PLATFORM_ANGLE_ANGLE)
     {
         return Display::GetDisplayFromNativeDisplay(
-            gl::bitCast<EGLNativeDisplayType>(native_display),
-            AttributeMap::CreateFromAttribArray(attrib_list));
+            gl::bitCast<EGLNativeDisplayType>(native_display), attribMap);
     }
     else if (platform == EGL_PLATFORM_DEVICE_EXT)
     {
         Device *eglDevice = reinterpret_cast<Device *>(native_display);
-        return Display::GetDisplayFromDevice(eglDevice);
+        return Display::GetDisplayFromDevice(eglDevice, attribMap);
     }
     else
     {

src/libGLESv2/entry_points_egl_ext.cpp

@@ -145,16 +145,16 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
         return EGL_NO_DISPLAY;
     }
 
+    const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
     if (platform == EGL_PLATFORM_ANGLE_ANGLE)
     {
         return Display::GetDisplayFromNativeDisplay(
-            gl::bitCast<EGLNativeDisplayType>(native_display),
-            AttributeMap::CreateFromIntArray(attrib_list));
+            gl::bitCast<EGLNativeDisplayType>(native_display), attribMap);
     }
     else if (platform == EGL_PLATFORM_DEVICE_EXT)
     {
         Device *eglDevice = reinterpret_cast<Device *>(native_display);
-        return Display::GetDisplayFromDevice(eglDevice);
+        return Display::GetDisplayFromDevice(eglDevice, attribMap);
     }
     else
     {

src/tests/gl_tests/RobustResourceInitTest.cpp

@@ -23,21 +23,15 @@ class RobustResourceInitTest : public ANGLETest
         setConfigGreenBits(8);
         setConfigBlueBits(8);
         setConfigAlphaBits(8);
-
-        // Defer context init until the test body.
-        setDeferContextInit(true);
-        setRobustResourceInit(true);
     }
 
     bool hasEGLExtension()
     {
-        EGLDisplay display = getEGLWindow()->getDisplay();
-        ASSERT(display != EGL_NO_DISPLAY);
-
-        return (eglDisplayExtensionEnabled(
-            display, "EGL_ANGLE_create_context_robust_resource_initialization"));
+        return eglClientExtensionEnabled("EGL_ANGLE_display_robust_resource_initialization");
     }
 
+    bool hasGLExtension() { return extensionEnabled("GL_ANGLE_robust_resource_initialization"); }
+
     bool setup()
     {
         if (!hasEGLExtension())
@@ -45,27 +39,22 @@ class RobustResourceInitTest : public ANGLETest
             return false;
         }
 
-        if (!getEGLWindow()->initializeContext())
-        {
-            EXPECT_TRUE(false);
-            return false;
-        }
+        TearDown();
+        setRobustResourceInit(true);
+        SetUp();
 
         return true;
     }
 };
 
-// Context creation should fail if EGL_ANGLE_create_context_robust_resource_initialization
+// Display creation should fail if EGL_ANGLE_display_robust_resource_initialization
 // is not available, and succeed otherwise.
 TEST_P(RobustResourceInitTest, ExtensionInit)
 {
-    if (hasEGLExtension())
+    if (setup())
     {
-        // Context creation shold succeed with robust resource init enabled.
-        EXPECT_TRUE(getEGLWindow()->initializeContext());
-
         // Robust resource init extension should be available.
-        EXPECT_TRUE(extensionEnabled("GL_ANGLE_robust_resource_initialization"));
+        EXPECT_TRUE(hasGLExtension());
 
         // Querying the state value should return true.
         GLboolean enabled = 0;
@@ -77,15 +66,8 @@ TEST_P(RobustResourceInitTest, ExtensionInit)
     }
     else
     {
-        // Context creation should fail with robust resource init enabled.
-        EXPECT_FALSE(getEGLWindow()->initializeContext());
-
-        // Context creation should succeed with robust resource init disabled.
-        setRobustResourceInit(false);
-        ASSERT_TRUE(getEGLWindow()->initializeGL(GetOSWindow()));
-
         // If context extension string exposed, check queries.
-        if (extensionEnabled("GL_ANGLE_robust_resource_initialization"))
+        if (hasGLExtension())
         {
             GLboolean enabled = 0;
             glGetBooleanv(GL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE, &enabled);
@@ -115,11 +97,8 @@ TEST_P(RobustResourceInitTest, QueriesOnNonRobustContext)
         return;
     }
 
-    setRobustResourceInit(false);
-    EXPECT_TRUE(getEGLWindow()->initializeContext());
-
     // If context extension string exposed, check queries.
-    ASSERT_TRUE(extensionEnabled("GL_ANGLE_robust_resource_initialization"));
+    ASSERT_TRUE(hasGLExtension());
 
     // Querying robust resource init should return INVALID_ENUM.
     GLboolean enabled = 0;

src/tests/test_utils/ANGLETest.cpp

@@ -590,33 +590,26 @@ void ANGLETest::checkD3D11SDKLayersMessages()
 #endif
 }
 
-static bool checkExtensionExists(const char *allExtensions, const std::string &extName)
-{
-    const std::string paddedExtensions = std::string(" ") + allExtensions + std::string(" ");
-    return paddedExtensions.find(std::string(" ") + extName + std::string(" ")) !=
-           std::string::npos;
-}
-
 bool ANGLETest::extensionEnabled(const std::string &extName)
 {
-    return checkExtensionExists(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)),
+    return CheckExtensionExists(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)),
                                 extName);
 }
 
 bool ANGLETest::extensionRequestable(const std::string &extName)
 {
-    return checkExtensionExists(
+    return CheckExtensionExists(
         reinterpret_cast<const char *>(glGetString(GL_REQUESTABLE_EXTENSIONS_ANGLE)), extName);
 }
 
 bool ANGLETest::eglDisplayExtensionEnabled(EGLDisplay display, const std::string &extName)
 {
-    return checkExtensionExists(eglQueryString(display, EGL_EXTENSIONS), extName);
+    return CheckExtensionExists(eglQueryString(display, EGL_EXTENSIONS), extName);
 }
 
 bool ANGLETest::eglClientExtensionEnabled(const std::string &extName)
 {
-    return checkExtensionExists(eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS), extName);
+    return EGLWindow::ClientExtensionEnabled(extName);
 }
 
 bool ANGLETest::eglDeviceExtensionEnabled(EGLDeviceEXT device, const std::string &extName)
@@ -624,7 +617,7 @@ bool ANGLETest::eglDeviceExtensionEnabled(EGLDeviceEXT device, const std::string
     PFNEGLQUERYDEVICESTRINGEXTPROC eglQueryDeviceStringEXT =
         reinterpret_cast<PFNEGLQUERYDEVICESTRINGEXTPROC>(
             eglGetProcAddress("eglQueryDeviceStringEXT"));
-    return checkExtensionExists(eglQueryDeviceStringEXT(device, EGL_EXTENSIONS), extName);
+    return CheckExtensionExists(eglQueryDeviceStringEXT(device, EGL_EXTENSIONS), extName);
 }
 
 void ANGLETest::setWindowWidth(int width)

util/EGLWindow.cpp

@@ -119,7 +119,7 @@ EGLWindow::EGLWindow(EGLint glesMajorVersion,
       mWebGLCompatibility(false),
       mBindGeneratesResource(true),
       mClientArraysEnabled(true),
-      mRobustResourceInit(false),
+      mRobustResourceInit(),
       mSwapInterval(-1),
       mSamples(-1),
       mPlatformMethods(nullptr)
@@ -207,6 +207,20 @@ bool EGLWindow::initializeDisplayAndSurface(OSWindow *osWindow)
         displayAttributes.push_back(reinterpret_cast<EGLAttrib>(mPlatformMethods));
     }
 
+    if (mRobustResourceInit.valid() &&
+        !ClientExtensionEnabled("EGL_ANGLE_display_robust_resource_initialization"))
+    {
+        // Non-default state requested without the extension present
+        destroyGL();
+        return false;
+    }
+
+    if (mRobustResourceInit.valid())
+    {
+        displayAttributes.push_back(EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE);
+        displayAttributes.push_back(mRobustResourceInit.value() ? EGL_TRUE : EGL_FALSE);
+    }
+
     displayAttributes.push_back(EGL_NONE);
 
     mDisplay = eglGetPlatformDisplay(EGL_PLATFORM_ANGLE_ANGLE,
@@ -324,16 +338,6 @@ bool EGLWindow::initializeContext()
         return false;
     }
 
-    bool hasRobustResourceInit =
-        strstr(displayExtensions, "EGL_ANGLE_create_context_robust_resource_initialization") !=
-        nullptr;
-    if (mRobustResourceInit && !hasRobustResourceInit)
-    {
-        // Non-default state requested without the extension present
-        destroyGL();
-        return false;
-    }
-
     eglBindAPI(EGL_OPENGL_ES_API);
     if (eglGetError() != EGL_SUCCESS)
     {
@@ -377,12 +381,6 @@ bool EGLWindow::initializeContext()
             contextAttributes.push_back(EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE);
             contextAttributes.push_back(mClientArraysEnabled ? EGL_TRUE : EGL_FALSE);
         }
-
-        if (hasRobustResourceInit)
-        {
-            contextAttributes.push_back(EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE);
-            contextAttributes.push_back(mRobustResourceInit ? EGL_TRUE : EGL_FALSE);
-        }
     }
     contextAttributes.push_back(EGL_NONE);
 
@@ -476,3 +474,16 @@ EGLBoolean EGLWindow::FindEGLConfig(EGLDisplay dpy, const EGLint *attrib_list, E
 
     return EGL_FALSE;
 }
+
+// static
+bool EGLWindow::ClientExtensionEnabled(const std::string &extName)
+{
+    return CheckExtensionExists(eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS), extName);
+}
+
+bool CheckExtensionExists(const char *allExtensions, const std::string &extName)
+{
+    const std::string paddedExtensions = std::string(" ") + allExtensions + std::string(" ");
+    return paddedExtensions.find(std::string(" ") + extName + std::string(" ")) !=
+           std::string::npos;
+}

util/EGLWindow.h

@@ -127,6 +127,8 @@ class ANGLE_EXPORT EGLWindow : angle::NonCopyable
     void destroyGL();
     bool isGLInitialized() const;
 
+    static bool ClientExtensionEnabled(const std::string &extName);
+
   private:
     EGLConfig mConfig;
     EGLDisplay mDisplay;
@@ -151,11 +153,13 @@ class ANGLE_EXPORT EGLWindow : angle::NonCopyable
     bool mWebGLCompatibility;
     bool mBindGeneratesResource;
     bool mClientArraysEnabled;
-    bool mRobustResourceInit;
+    Optional<bool> mRobustResourceInit;
     EGLint mSwapInterval;
     EGLint mSamples;
     Optional<bool> mVulkanLayersEnabled;
     angle::PlatformMethods *mPlatformMethods;
 };
 
+ANGLE_EXPORT bool CheckExtensionExists(const char *allExtensions, const std::string &extName);
+
 #endif // UTIL_EGLWINDOW_H_