Change robust resource init into a context creation attribute.

extensions/ANGLE_robust_resource_initialization.txt

 Name
 
-    ANGLE_robust_resource_initialization.txt
+    ANGLE_robust_resource_initialization
 
 Name Strings
 
-    ANGLE_robust_resource_intialization
+    GL_ANGLE_robust_resource_intialization
 
 Contributors
 
@@ -21,7 +21,7 @@ Status
 
 Version
 
-    Version 1, January 7, 2015
+    Version 3, September 19, 2017
 
 Number
 
@@ -34,7 +34,7 @@ Dependencies
     This extension is written against the wording of the OpenGL ES
     3.1 specification.
 
-    EGL_ANGLE_create_context_robust_initialization is required to request a
+    EGL_ANGLE_robust_initialization is required to request a
     context that supports this extension, and resource initialization.
 
 Overview
@@ -57,7 +57,7 @@ New Tokens
     Accepted by the <value> parameter of GetBooleanv, GetIntegerv,
     GetFloatv, GetDoublev, GetInteger64v, and IsEnabled:
 
-        CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE    0x93A7
+        ROBUST_RESOURCE_INITIALIZATION_ANGLE    0x93A7
 
 Additions to Chapter 6 of the OpenGL ES 3.1 Specification (Buffer
 Objects)
@@ -141,3 +141,4 @@ Revision History
 
     Version 1, 2015/01/07 - first draft.
     Version 2, 2017/03/07 - fixed EGL naming and added IsEnabled.
+    Version 3, 2017/09/19 - name cleanup.

extensions/EGL_ANGLE_display_robust_resource_initialization.txt → extensions/EGL_ANGLE_robust_resource_initialization.txt

 Name
 
-    EGL_ANGLE_display_robust_resource_initialization.txt
+    ANGLE_robust_resource_initialization
 
 Name Strings
 
-    EGL_ANGLE_display_robust_resource_initialization
+    EGL_ANGLE_robust_resource_initialization
 
 Contributors
 
@@ -21,7 +21,7 @@ Status
 
 Version
 
-    Version 1, January 7, 2015
+    Version 4, September 19, 2017
 
 Number
 
@@ -35,13 +35,10 @@ 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 initializing an OpenGL ES Display supporting
-    robust resource initialization.
+    This extension allows creating an OpenGL ES context or EGL surface
+    supporting robust resource initialization.
 
 New Types
 
@@ -53,40 +50,72 @@ New Procedures and Functions
 
 New Tokens
 
-    Accepted as an attribute name in the <*attrib_list> argument to
-    eglGetPlatformDisplay:
+    Accepted as an attribute name by eglCreateContext, eglQueryContext,
+    eglCreateWindowSurface, eglCreatePbufferSurface, eglCreatePixmapSurface,
+    and eglQuerySurface:
 
-        EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE    0x3453
+        EGL_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.2:
-
-    "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.
-    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
+    to section 3.7.1:
+
+    "If the attribute EGL_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
+    functionality. This attribute is supported only for OpenGL ES contexts.
+    The default value of EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE
     is EGL_FALSE."
 
+    Add a new paragraph to section 3.7.4 "Context Queries" under
+    eglQueryContext:
+
+    "Querying EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE returns if
+    the context was created using robust initialization."
+
+    Add a new paragrah to section 3.5.1 "Creating On-Screen Rendering
+    Surfaces" and section 3.5.2 "Creating Off-Screen Rendering Surfaces":
+
+    "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE specifies if the pixel
+    values of the surface are initialized.  If its value is EGL_TRUE then all
+    pixel values in the surface are initialized to zero, otherwise the contents
+    are undefined. The default value of
+    EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE is EGL_FALSE."
+
+    Add a new paragrah to section 3.5.6 "Surface Attributes" under
+    eglQuerySurface:
+
+    "Querying EGL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE returns if
+    the surface was created using robust initialization."
+
+    Modify the 2nd paragraph of section 3.10.1 "Posting to a Window":
+
+    "... The contents of the color buffer are undefined if the value of the
+    EGL_SWAP_BEHAVIOR attribute of surface is not EGL_BUFFER_PRESERVED and
+    the value of the EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE is
+    EGL_FALSE. ..."
+
 Issues
 
     (1) Should this be a Display or Context creation extension?
 
-    RESOLVED: Making this a Context creation extension has complications in
+    RESOLVED (3): 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.
 
+    RESOLVED (4): This extension has been moved back to a context/surface
+    creation attribute. This makes the extension much easier to detect before
+    the GL context is created.
+
 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
+    Version 3, 2017/05/31 - renamed extension and made into display extension.
+    Version 4, 2017/09/19 - renamed extension and changed into a
+                            context/surface creation attribute.
\ No newline at end of file

include/EGL/eglext_angle.h

@@ -12,10 +12,10 @@
 
 // clang-format off
 
-#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_robust_resource_initialization
+#define EGL_ANGLE_robust_resource_initialization 1
+#define EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE 0x3453
+#endif /* EGL_ANGLE_robust_resource_initialization */
 
 #ifndef EGL_ANGLE_keyed_mutex
 #define EGL_ANGLE_keyed_mutex 1

include/GLES2/gl2ext_angle.h

@@ -29,7 +29,7 @@ GL_APICALL void 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 0x93AB
+#define GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE 0x93AB
 #endif /* GL_ANGLE_robust_resource_initialization */
 
 #ifndef GL_CHROMIUM_framebuffer_mixed_samples

src/libANGLE/Caps.cpp

@@ -1087,7 +1087,8 @@ DisplayExtensions::DisplayExtensions()
       surfacelessContext(false),
       displayTextureShareGroup(false),
       createContextClientArrays(false),
-      programCacheControl(false)
+      programCacheControl(false),
+      robustResourceInitialization(false)
 {
 }
 
@@ -1131,6 +1132,7 @@ std::vector<std::string> DisplayExtensions::getStrings() const
     InsertExtensionString("EGL_ANGLE_display_texture_share_group",               displayTextureShareGroup,           &extensionStrings);
     InsertExtensionString("EGL_ANGLE_create_context_client_arrays",              createContextClientArrays,          &extensionStrings);
     InsertExtensionString("EGL_ANGLE_program_cache_control",                     programCacheControl,                &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_robust_resource_initialization",            robustResourceInitialization,       &extensionStrings);
     // TODO(jmadill): Enable this when complete.
     //InsertExtensionString("KHR_create_context_no_error",                       createContextNoError,               &extensionStrings);
     // clang-format on
@@ -1165,8 +1167,7 @@ ClientExtensions::ClientExtensions()
       deviceCreationD3D11(false),
       x11Visual(false),
       experimentalPresentPath(false),
-      clientGetAllProcAddresses(false),
-      displayRobustResourceInitialization(false)
+      clientGetAllProcAddresses(false)
 {
 }
 
@@ -1189,7 +1190,6 @@ 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;

src/libANGLE/Caps.h

@@ -672,6 +672,9 @@ struct DisplayExtensions
 
     // EGL_ANGLE_program_cache_control
     bool programCacheControl;
+
+    // EGL_ANGLE_robust_resource_initialization
+    bool robustResourceInitialization;
 };
 
 struct DeviceExtensions
@@ -730,9 +733,6 @@ 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

@@ -210,6 +210,11 @@ 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_ROBUST_RESOURCE_INITIALIZATION_ANGLE, EGL_FALSE) == EGL_TRUE);
+}
+
 std::string GetObjectLabelFromPointer(GLsizei length, const GLchar *label)
 {
     std::string labelName;
@@ -257,8 +262,7 @@ Context::Context(rx::EGLImplFactory *implFactory,
                  TextureManager *shareTextures,
                  MemoryProgramCache *memoryProgramCache,
                  const egl::AttributeMap &attribs,
-                 const egl::DisplayExtensions &displayExtensions,
-                 bool robustResourceInit)
+                 const egl::DisplayExtensions &displayExtensions)
 
     : ValidationContext(shareContext,
                         shareTextures,
@@ -289,7 +293,8 @@ Context::Context(rx::EGLImplFactory *implFactory,
 {
     mImplementation->setMemoryProgramCache(memoryProgramCache);
 
-    initCaps(displayExtensions);
+    bool robustResourceInit = GetRobustResourceInit(attribs);
+    initCaps(displayExtensions, robustResourceInit);
     initWorkarounds();
 
     mGLState.initialize(this, GetDebug(attribs), GetBindGeneratesResource(attribs),
@@ -2618,7 +2623,7 @@ bool Context::hasActiveTransformFeedback(GLuint program) const
     return false;
 }
 
-void Context::initCaps(const egl::DisplayExtensions &displayExtensions)
+void Context::initCaps(const egl::DisplayExtensions &displayExtensions, bool robustResourceInit)
 {
     mCaps = mImplementation->getNativeCaps();
 
@@ -2666,8 +2671,7 @@ void Context::initCaps(const egl::DisplayExtensions &displayExtensions)
     mExtensions.robustClientMemory = true;
 
     // Determine robust resource init availability from EGL.
-    mExtensions.robustResourceInitialization =
-        egl::Display::GetClientExtensions().displayRobustResourceInitialization;
+    mExtensions.robustResourceInitialization = robustResourceInit;
 
     // mExtensions.robustBufferAccessBehavior is true only if robust access is true and the backend
     // supports it.

src/libANGLE/Context.h

@@ -69,8 +69,7 @@ class Context final : public ValidationContext
             TextureManager *shareTextures,
             MemoryProgramCache *memoryProgramCache,
             const egl::AttributeMap &attribs,
-            const egl::DisplayExtensions &displayExtensions,
-            bool robustResourceInit);
+            const egl::DisplayExtensions &displayExtensions);
 
     egl::Error onDestroy(const egl::Display *display);
     ~Context() override;
@@ -973,7 +972,7 @@ class Context final : public ValidationContext
     void initVersionStrings();
     void initExtensionStrings();
 
-    void initCaps(const egl::DisplayExtensions &displayExtensions);
+    void initCaps(const egl::DisplayExtensions &displayExtensions, bool robustResourceInit);
     void updateCaps();
     void initWorkarounds();
 

src/libANGLE/ContextState.cpp

@@ -451,7 +451,7 @@ bool ValidationContext::getQueryParameterInfo(GLenum pname, GLenum *type, unsign
     }
 
     if (getExtensions().robustResourceInitialization &&
-        pname == GL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE)
+        pname == GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE)
     {
         *type      = GL_BOOL;
         *numParams = 1;

src/libANGLE/Display.cpp

@@ -493,7 +493,7 @@ Error Display::initialize()
 
     mProxyContext.reset(nullptr);
     gl::Context *proxyContext = new gl::Context(mImplementation, nullptr, nullptr, nullptr, nullptr,
-                                                egl::AttributeMap(), mDisplayExtensions, false);
+                                                egl::AttributeMap(), mDisplayExtensions);
     mProxyContext.reset(proxyContext);
 
     mInitialized = true;
@@ -757,7 +757,7 @@ Error Display::createContext(const Config *configuration,
 
     gl::Context *context =
         new gl::Context(mImplementation, configuration, shareContext, shareTextures, cachePointer,
-                        attribs, mDisplayExtensions, isRobustResourceInitEnabled());
+                        attribs, mDisplayExtensions);
 
     ASSERT(context != nullptr);
     mContextSet.insert(context);
@@ -980,9 +980,6 @@ static ClientExtensions GenerateClientExtensions()
 
     extensions.clientGetAllProcAddresses = true;
 
-    // TODO(jmadill): Not fully implemented yet, but exposed everywhere.
-    extensions.displayRobustResourceInitialization = true;
-
     return extensions;
 }
 
@@ -1119,12 +1116,6 @@ 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);
-}
-
 EGLint Display::programCacheGetAttrib(EGLenum attrib) const
 {
     switch (attrib)

src/libANGLE/Display.h

@@ -158,8 +158,6 @@ class Display final : angle::NonCopyable
 
     const DisplayState &getState() const { return mState; }
 
-    bool isRobustResourceInitEnabled() const;
-
     gl::Context *getProxyContext() const { return mProxyContext.get(); }
 
   private:

src/libANGLE/State.cpp

@@ -728,7 +728,7 @@ bool State::getEnableFeature(GLenum feature) const
           return areClientArraysEnabled();
       case GL_FRAMEBUFFER_SRGB_EXT:
           return getFramebufferSRGB();
-      case GL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+      case GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
           return mRobustResourceInit;
       case GL_PROGRAM_CACHE_ENABLED_ANGLE:
           return mProgramBinaryCacheEnabled;
@@ -1735,7 +1735,7 @@ void State::getBooleanv(GLenum pname, GLboolean *params)
       case GL_FRAMEBUFFER_SRGB_EXT:
           *params = getFramebufferSRGB() ? GL_TRUE : GL_FALSE;
           break;
-      case GL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+      case GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
           *params = mRobustResourceInit ? GL_TRUE : GL_FALSE;
           break;
       case GL_PROGRAM_CACHE_ENABLED_ANGLE:

src/libANGLE/Surface.cpp

@@ -80,6 +80,9 @@ Surface::Surface(EGLint surfaceType, const egl::Config *config, const AttributeM
 
     mDirectComposition = (attributes.get(EGL_DIRECT_COMPOSITION_ANGLE, EGL_FALSE) == EGL_TRUE);
 
+    mRobustResourceInitialization =
+        (attributes.get(EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE, EGL_FALSE) == EGL_TRUE);
+
     mFixedSize = (attributes.get(EGL_FIXED_SIZE_ANGLE, EGL_FALSE) == EGL_TRUE);
     if (mFixedSize)
     {

src/libANGLE/Surface.h

@@ -123,6 +123,8 @@ class Surface : public gl::FramebufferAttachmentObject
     gl::InitState initState(const gl::ImageIndex &imageIndex) const override;
     void setInitState(const gl::ImageIndex &imageIndex, gl::InitState initState) override;
 
+    bool isRobustResourceInitEnabled() const { return mRobustResourceInitialization; }
+
   protected:
     Surface(EGLint surfaceType, const egl::Config *config, const AttributeMap &attributes);
     virtual ~Surface();
@@ -160,6 +162,8 @@ class Surface : public gl::FramebufferAttachmentObject
 
     bool mDirectComposition;
 
+    bool mRobustResourceInitialization;
+
     EGLenum mTextureFormat;
     EGLenum mTextureTarget;
 

src/libANGLE/queryutils.cpp

@@ -1605,6 +1605,9 @@ void QueryContextAttrib(const gl::Context *context, EGLint attribute, EGLint *va
         case EGL_RENDER_BUFFER:
             *value = context->getRenderBuffer();
             break;
+        case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+            *value = context->isRobustResourceInitEnabled();
+            break;
         default:
             UNREACHABLE();
             break;
@@ -1701,6 +1704,9 @@ void QuerySurfaceAttrib(const Surface *surface, EGLint attribute, EGLint *value)
         case EGL_DIRECT_COMPOSITION_ANGLE:
             *value = surface->directComposition();
             break;
+        case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+            *value = surface->isRobustResourceInitEnabled();
+            break;
         default:
             UNREACHABLE();
             break;

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

@@ -1214,6 +1214,9 @@ void Renderer11::generateDisplayExtensions(egl::DisplayExtensions *outExtensions
 
     // D3D11 can be used without a swap chain
     outExtensions->surfacelessContext = true;
+
+    // All D3D feature levels support robust resource init
+    outExtensions->robustResourceInitialization = true;
 }
 
 gl::Error Renderer11::flush()

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -577,6 +577,8 @@ void Renderer9::generateDisplayExtensions(egl::DisplayExtensions *outExtensions)
 
     // D3D9 can be used without an output surface
     outExtensions->surfacelessContext = true;
+
+    outExtensions->robustResourceInitialization = true;
 }
 
 void Renderer9::startScene()

src/libANGLE/renderer/gl/DisplayGL.cpp

@@ -109,6 +109,13 @@ gl::Version DisplayGL::getMaxSupportedESVersion() const
     return mRenderer->getMaxSupportedESVersion();
 }
 
+void DisplayGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
+{
+    // Advertise robust resource initialization on all OpenGL backends for testing even though it is
+    // not fully implemented.
+    outExtensions->robustResourceInitialization = true;
+}
+
 egl::Error DisplayGL::makeCurrentSurfaceless(gl::Context *context)
 {
     UNIMPLEMENTED();

src/libANGLE/renderer/gl/DisplayGL.h

@@ -48,6 +48,8 @@ class DisplayGL : public DisplayImpl
   protected:
     RendererGL *getRenderer() const { return mRenderer; };
 
+    void generateExtensions(egl::DisplayExtensions *outExtensions) const override;
+
   private:
     virtual const FunctionsGL *getFunctionsGL() const = 0;
     virtual egl::Error makeCurrentSurfaceless(gl::Context *context);

src/libANGLE/renderer/gl/cgl/DisplayCGL.mm

@@ -249,6 +249,8 @@ void DisplayCGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
 
     // Contexts are virtualized so textures can be shared globally
     outExtensions->displayTextureShareGroup = true;
+
+    DisplayGL::generateExtensions(outExtensions);
 }
 
 void DisplayCGL::generateCaps(egl::Caps *outCaps) const

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

@@ -110,6 +110,8 @@ void DisplayEGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
 
     // Surfaceless contexts are emulated even if there is no native support.
     outExtensions->surfacelessContext = true;
+
+    DisplayGL::generateExtensions(outExtensions);
 }
 
 void DisplayEGL::generateCaps(egl::Caps *outCaps) const

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

@@ -791,6 +791,8 @@ void DisplayGLX::generateExtensions(egl::DisplayExtensions *outExtensions) const
     outExtensions->displayTextureShareGroup = true;
 
     outExtensions->surfacelessContext = true;
+
+    DisplayGL::generateExtensions(outExtensions);
 }
 
 void DisplayGLX::generateCaps(egl::Caps *outCaps) const

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

@@ -625,6 +625,8 @@ void DisplayWGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
     outExtensions->displayTextureShareGroup = true;
 
     outExtensions->surfacelessContext = true;
+
+    DisplayGL::generateExtensions(outExtensions);
 }
 
 void DisplayWGL::generateCaps(egl::Caps *outCaps) const

src/libANGLE/renderer/null/DisplayNULL.cpp

@@ -206,6 +206,7 @@ void DisplayNULL::generateExtensions(egl::DisplayExtensions *outExtensions) cons
     outExtensions->displayTextureShareGroup           = true;
     outExtensions->createContextClientArrays          = true;
     outExtensions->programCacheControl                = true;
+    outExtensions->robustResourceInitialization       = true;
 }
 
 void DisplayNULL::generateCaps(egl::Caps *outCaps) const

src/libANGLE/validationEGL.cpp

@@ -398,21 +398,6 @@ Error ValidateGetPlatformDisplayCommon(EGLenum platform,
                     }
                     break;
 
-                case EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
-                    if (!clientExtensions.displayRobustResourceInitialization)
-                    {
-                        return EglBadAttribute()
-                               << "Attribute EGL_DISPLAY_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
-                                  "requires EGL_ANGLE_display_robust_resource_initialization.";
-                    }
-                    if (value != EGL_TRUE && value != EGL_FALSE)
-                    {
-                        return EglBadAttribute() << "EGL_DISPLAY_ROBUST_RESOURCE_"
-                                                    "INITIALIZATION_ANGLE must be either "
-                                                    "EGL_TRUE or EGL_FALSE.";
-                    }
-                    break;
-
                 default:
                     break;
             }
@@ -726,6 +711,19 @@ Error ValidateCreateContext(Display *display, Config *configuration, gl::Context
               }
               break;
 
+          case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+              if (!display->getExtensions().robustResourceInitialization)
+              {
+                  return EglBadAttribute() << "Attribute EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
+                                              "requires EGL_ANGLE_robust_resource_initialization.";
+              }
+              if (value != EGL_TRUE && value != EGL_FALSE)
+              {
+                  return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE must be "
+                                              "either EGL_TRUE or EGL_FALSE.";
+              }
+              break;
+
           default:
               return EglBadAttribute() << "Unknown attribute.";
         }
@@ -875,6 +873,19 @@ Error ValidateCreateWindowSurface(Display *display, Config *config, EGLNativeWin
               }
               break;
 
+          case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+              if (!display->getExtensions().robustResourceInitialization)
+              {
+                  return EglBadAttribute() << "Attribute EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
+                                              "requires EGL_ANGLE_robust_resource_initialization.";
+              }
+              if (value != EGL_TRUE && value != EGL_FALSE)
+              {
+                  return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE must be "
+                                              "either EGL_TRUE or EGL_FALSE.";
+              }
+              break;
+
           default:
               return EglBadAttribute();
         }
@@ -953,6 +964,19 @@ Error ValidateCreatePbufferSurface(Display *display, Config *config, const Attri
               }
               break;
 
+          case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+              if (!display->getExtensions().robustResourceInitialization)
+              {
+                  return EglBadAttribute() << "Attribute EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
+                                              "requires EGL_ANGLE_robust_resource_initialization.";
+              }
+              if (value != EGL_TRUE && value != EGL_FALSE)
+              {
+                  return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE must be "
+                                              "either EGL_TRUE or EGL_FALSE.";
+              }
+              break;
+
           default:
               return EglBadAttribute();
         }
@@ -2426,6 +2450,15 @@ Error ValidateQuerySurface(const Display *display,
             }
             break;
 
+        case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+            if (!display->getExtensions().robustResourceInitialization)
+            {
+                return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE cannot be "
+                                            "used without EGL_ANGLE_robust_resource_initialization "
+                                            "support.";
+            }
+            break;
+
         default:
             return EglBadAttribute() << "Invalid surface attribute.";
     }
@@ -2449,6 +2482,15 @@ Error ValidateQueryContext(const Display *display,
         case EGL_RENDER_BUFFER:
             break;
 
+        case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+            if (!display->getExtensions().robustResourceInitialization)
+            {
+                return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE cannot be "
+                                            "used without EGL_ANGLE_robust_resource_initialization "
+                                            "support.";
+            }
+            break;
+
         default:
             return EglBadAttribute() << "Invalid context attribute.";
     }

src/libANGLE/validationES2.cpp

@@ -788,7 +788,7 @@ bool ValidCap(const Context *context, GLenum cap, bool queryOnly)
         case GL_SAMPLE_MASK:
             return context->getClientVersion() >= Version(3, 1);
 
-        case GL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+        case GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
             return queryOnly && context->getExtensions().robustResourceInitialization;
 
         default:

util/EGLWindow.cpp

@@ -210,20 +210,6 @@ 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,
@@ -291,6 +277,14 @@ bool EGLWindow::initializeDisplayAndSurface(OSWindow *osWindow)
         surfaceAttributes.push_back(EGL_TRUE);
     }
 
+    bool hasRobustResourceInit =
+        strstr(displayExtensions, "EGL_ANGLE_robust_resource_initialization") != nullptr;
+    if (hasRobustResourceInit && mRobustResourceInit.valid())
+    {
+        surfaceAttributes.push_back(EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE);
+        surfaceAttributes.push_back(mRobustResourceInit.value() ? EGL_TRUE : EGL_FALSE);
+    }
+
     surfaceAttributes.push_back(EGL_NONE);
 
     mSurface = eglCreateWindowSurface(mDisplay, mConfig, osWindow->getNativeWindow(), &surfaceAttributes[0]);
@@ -411,6 +405,14 @@ bool EGLWindow::initializeContext()
             contextAttributes.push_back(EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE);
             contextAttributes.push_back(mContextProgramCacheEnabled.value() ? EGL_TRUE : EGL_FALSE);
         }
+
+        bool hasRobustResourceInit =
+            strstr(displayExtensions, "EGL_ANGLE_robust_resource_initialization") != nullptr;
+        if (hasRobustResourceInit && mRobustResourceInit.valid())
+        {
+            contextAttributes.push_back(EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE);
+            contextAttributes.push_back(mRobustResourceInit.value() ? EGL_TRUE : EGL_FALSE);
+        }
     }
     contextAttributes.push_back(EGL_NONE);