Move EGL Display config into EGLPlatformParameters.

samples/sample_util/SampleApplication.cpp

@@ -56,18 +56,19 @@ SampleApplication::SampleApplication(std::string name,
       mEGLWindow(nullptr),
       mOSWindow(nullptr)
 {
-    EGLint requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+    mPlatformParams.majorVersion = glesMajorVersion;
+    mPlatformParams.minorVersion = glesMinorVersion;
+    mPlatformParams.renderer     = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
 
     if (argc > 1 && strncmp(argv[1], kUseAngleArg, strlen(kUseAngleArg)) == 0)
     {
-        requestedRenderer = GetDisplayTypeFromArg(argv[1] + strlen(kUseAngleArg));
+        mPlatformParams.renderer = GetDisplayTypeFromArg(argv[1] + strlen(kUseAngleArg));
     }
 
     // Load EGL library so we can initialize the display.
     mEntryPointsLib.reset(angle::OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME));
 
-    mEGLWindow = EGLWindow::New(glesMajorVersion, glesMinorVersion,
-                                EGLPlatformParameters(requestedRenderer));
+    mEGLWindow = EGLWindow::New(glesMajorVersion, glesMinorVersion);
     mTimer.reset(CreateTimer());
     mOSWindow = OSWindow::New();
 }
@@ -136,7 +137,7 @@ int SampleApplication::run()
     configParams.depthBits   = 24;
     configParams.stencilBits = 8;
 
-    if (!mEGLWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), configParams))
+    if (!mEGLWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), mPlatformParams, configParams))
     {
         return -1;
     }

samples/sample_util/SampleApplication.h

@@ -12,6 +12,7 @@
 #include <memory>
 #include <string>
 
+#include "util/EGLPlatformParameters.h"
 #include "util/OSWindow.h"
 #include "util/Timer.h"
 #include "util/egl_loader_autogen.h"
@@ -64,6 +65,8 @@ class SampleApplication
     EGLWindow *mEGLWindow;
     OSWindow *mOSWindow;
 
+    EGLPlatformParameters mPlatformParams;
+
     // Handle to the entry point binding library.
     std::unique_ptr<angle::Library> mEntryPointsLib;
 };

src/tests/gl_tests/MultithreadingTest.cpp

@@ -27,7 +27,6 @@ class MultithreadingTest : public ANGLETest
         setConfigGreenBits(8);
         setConfigBlueBits(8);
         setConfigAlphaBits(8);
-        setContextVirtualization(false);
     }
 
     bool platformSupportsMultithreading() const { return (IsOpenGLES() && IsAndroid()); }
@@ -158,9 +157,9 @@ TEST_P(MultithreadingTest, MakeCurrentMultiContext)
 // TODO(geofflang): Test sharing a program between multiple shared contexts on multiple threads
 
 ANGLE_INSTANTIATE_TEST(MultithreadingTest,
-                       ES2_OPENGL(),
-                       ES3_OPENGL(),
-                       ES2_OPENGLES(),
-                       ES3_OPENGLES());
+                       WithNoVirtualContexts(ES2_OPENGL()),
+                       WithNoVirtualContexts(ES3_OPENGL()),
+                       WithNoVirtualContexts(ES2_OPENGLES()),
+                       WithNoVirtualContexts(ES3_OPENGLES()));
 
 }  // namespace angle

src/tests/gl_tests/ProgramBinaryTest.cpp

@@ -719,11 +719,11 @@ class ProgramBinariesAcrossPlatforms : public testing::TestWithParam<PlatformsWi
 
     EGLWindow *createAndInitEGLWindow(angle::PlatformParameters &param)
     {
-        EGLWindow *eglWindow =
-            EGLWindow::New(param.majorVersion, param.minorVersion, param.eglParameters);
+        EGLWindow *eglWindow = EGLWindow::New(param.majorVersion, param.minorVersion);
         ConfigParameters configParams;
-        bool result = eglWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), configParams);
-        if (result == false)
+        bool result = eglWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), param.eglParameters,
+                                              configParams);
+        if (!result)
         {
             EGLWindow::Delete(&eglWindow);
         }

src/tests/perf_tests/ANGLEPerfTest.cpp

@@ -362,7 +362,7 @@ ANGLERenderTest::ANGLERenderTest(const std::string &name, const RenderTestParams
     switch (testParams.driver)
     {
         case angle::GLESDriverType::AngleEGL:
-            mGLWindow = createEGLWindow(testParams);
+            mGLWindow = EGLWindow::New(testParams.majorVersion, testParams.minorVersion);
             mEntryPointsLib.reset(angle::OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME));
             break;
         case angle::GLESDriverType::SystemEGL:
@@ -426,8 +426,6 @@ void ANGLERenderTest::SetUp()
     mPlatformMethods.monotonicallyIncreasingTime = MonotonicallyIncreasingTime;
     mPlatformMethods.context                     = this;
 
-    mConfigParams.platformMethods = &mPlatformMethods;
-
     if (!mOSWindow->initialize(mName, mTestParams.windowWidth, mTestParams.windowHeight))
     {
         mSkipTest = true;
@@ -435,7 +433,11 @@ void ANGLERenderTest::SetUp()
         // FAIL returns.
     }
 
-    if (!mGLWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), mConfigParams))
+    // Override platform method parameter.
+    EGLPlatformParameters withMethods = mTestParams.eglParameters;
+    withMethods.platformMethods       = &mPlatformMethods;
+
+    if (!mGLWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), withMethods, mConfigParams))
     {
         mSkipTest = true;
         FAIL() << "Failed initializing GL Window";
@@ -607,10 +609,3 @@ std::vector<TraceEvent> &ANGLERenderTest::getTraceEventBuffer()
 {
     return mTraceEventBuffer;
 }
-
-// static
-EGLWindow *ANGLERenderTest::createEGLWindow(const RenderTestParams &testParams)
-{
-    return EGLWindow::New(testParams.majorVersion, testParams.minorVersion,
-                          testParams.eglParameters);
-}

src/tests/perf_tests/ANGLEPerfTest.h

@@ -157,8 +157,6 @@ class ANGLERenderTest : public ANGLEPerfTest
 
     bool areExtensionPrerequisitesFulfilled() const;
 
-    static EGLWindow *createEGLWindow(const RenderTestParams &testParams);
-
     GLWindowBase *mGLWindow;
     OSWindow *mOSWindow;
     std::vector<const char *> mExtensionPrerequisites;

src/tests/test_utils/ANGLETest.h

@@ -360,11 +360,9 @@ class ANGLETestBase
     void setExtensionsEnabled(bool extensionsEnabled);
     void setRobustAccess(bool enabled);
     void setBindGeneratesResource(bool bindGeneratesResource);
-    void setDebugLayersEnabled(bool enabled);
     void setClientArraysEnabled(bool enabled);
     void setRobustResourceInit(bool enabled);
     void setContextProgramCacheEnabled(bool enabled, angle::CacheProgramFunc cacheProgramFunc);
-    void setContextVirtualization(bool enabled);
     void setContextResetStrategy(EGLenum resetStrategy);
     void forceNewDisplay();
 
@@ -387,7 +385,7 @@ class ANGLETestBase
     // Allows a test to be more restrictive about platform warnings.
     void treatPlatformWarningsAsErrors();
 
-    OSWindow *getOSWindow() { return mCurrentPlatform->osWindow; }
+    OSWindow *getOSWindow() { return mFixture->osWindow; }
 
     GLuint get2DTexturedQuadProgram();
 
@@ -412,10 +410,10 @@ class ANGLETestBase
                   bool useInstancedDrawCalls,
                   GLuint numInstances);
 
-    struct Platform
+    struct TestFixture
     {
-        Platform();
-        ~Platform();
+        TestFixture();
+        ~TestFixture();
 
         EGLWindow *eglWindow = nullptr;
         WGLWindow *wglWindow = nullptr;
@@ -446,8 +444,9 @@ class ANGLETestBase
     // different config. This OSWindow sharing seemed to lead to driver bugs on some platforms.
     static OSWindow *mOSWindowSingleton;
 
-    static std::map<angle::PlatformParameters, Platform> gPlatforms;
-    Platform *mCurrentPlatform;
+    static std::map<angle::PlatformParameters, TestFixture> gPlatforms;
+    const angle::PlatformParameters *mCurrentParams;
+    TestFixture *mFixture;
 
     // Workaround for NVIDIA not being able to share a window with OpenGL and Vulkan.
     static Optional<EGLint> mLastRendererType;

src/tests/test_utils/angle_test_configs.cpp

@@ -12,47 +12,51 @@
 namespace angle
 {
 
-PlatformParameters::PlatformParameters() : PlatformParameters(2, 0, EGLPlatformParameters()) {}
+PlatformParameters::PlatformParameters() : PlatformParameters(2, 0, GLESDriverType::AngleEGL) {}
 
 PlatformParameters::PlatformParameters(EGLint majorVersion,
                                        EGLint minorVersion,
                                        const EGLPlatformParameters &eglPlatformParameters)
-    : majorVersion(majorVersion),
-      minorVersion(minorVersion),
+    : driver(GLESDriverType::AngleEGL),
       eglParameters(eglPlatformParameters),
-      driver(GLESDriverType::AngleEGL)
-{}
+      majorVersion(majorVersion),
+      minorVersion(minorVersion)
+{
+    initDefaultParameters();
+}
 
 PlatformParameters::PlatformParameters(EGLint majorVersion,
                                        EGLint minorVersion,
                                        GLESDriverType driver)
-    : majorVersion(majorVersion), minorVersion(minorVersion), driver(driver)
-{}
+    : driver(driver), majorVersion(majorVersion), minorVersion(minorVersion)
+{
+    initDefaultParameters();
+}
 
 EGLint PlatformParameters::getRenderer() const
 {
     return eglParameters.renderer;
 }
 
-bool operator<(const PlatformParameters &a, const PlatformParameters &b)
+void PlatformParameters::initDefaultParameters()
 {
-    if (a.majorVersion != b.majorVersion)
-    {
-        return a.majorVersion < b.majorVersion;
-    }
-
-    if (a.minorVersion != b.minorVersion)
-    {
-        return a.minorVersion < b.minorVersion;
-    }
+    // Default debug layers to enabled in tests.
+    eglParameters.debugLayersEnabled = EGL_TRUE;
+}
 
-    return a.eglParameters < b.eglParameters;
+bool operator<(const PlatformParameters &a, const PlatformParameters &b)
+{
+    return a.tie() < b.tie();
 }
 
 bool operator==(const PlatformParameters &a, const PlatformParameters &b)
 {
-    return (a.majorVersion == b.majorVersion) && (a.minorVersion == b.minorVersion) &&
-           (a.eglParameters == b.eglParameters);
+    return a.tie() == b.tie();
+}
+
+bool operator!=(const PlatformParameters &a, const PlatformParameters &b)
+{
+    return a.tie() != b.tie();
 }
 
 std::ostream &operator<<(std::ostream &stream, const PlatformParameters &pp)
@@ -160,6 +164,11 @@ std::ostream &operator<<(std::ostream &stream, const PlatformParameters &pp)
             break;
     }
 
+    if (pp.eglParameters.contextVirtualization == EGL_FALSE)
+    {
+        stream << "_NO_VIRTUAL";
+    }
+
     return stream;
 }
 

src/tests/test_utils/angle_test_configs.h

@@ -45,10 +45,14 @@ struct PlatformParameters
 
     EGLint getRenderer() const;
 
+    void initDefaultParameters();
+
+    auto tie() const { return std::tie(driver, eglParameters, majorVersion, minorVersion); }
+
+    GLESDriverType driver;
+    EGLPlatformParameters eglParameters;
     EGLint majorVersion;
     EGLint minorVersion;
-    EGLPlatformParameters eglParameters;
-    GLESDriverType driver;
 };
 
 bool operator<(const PlatformParameters &a, const PlatformParameters &b);
@@ -173,6 +177,13 @@ PlatformParameters ES3_VULKAN_NULL();
 PlatformParameters ES2_WGL();
 PlatformParameters ES3_WGL();
 
+inline PlatformParameters WithNoVirtualContexts(const PlatformParameters &params)
+{
+    PlatformParameters withNoVirtualContexts                  = params;
+    withNoVirtualContexts.eglParameters.contextVirtualization = EGL_FALSE;
+    return withNoVirtualContexts;
+}
+
 }  // namespace angle
 
 #endif  // ANGLE_TEST_CONFIGS_H_

src/tests/test_utils/angle_test_instantiate.cpp

@@ -36,10 +36,10 @@ bool IsANGLEConfigSupported(const PlatformParameters &param, OSWindow *osWindow)
     eglLibrary.reset(angle::OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME));
 #endif
 
-    EGLWindow *eglWindow =
-        EGLWindow::New(param.majorVersion, param.minorVersion, param.eglParameters);
+    EGLWindow *eglWindow = EGLWindow::New(param.majorVersion, param.minorVersion);
     ConfigParameters configParams;
-    bool result = eglWindow->initializeGL(osWindow, eglLibrary.get(), configParams);
+    bool result =
+        eglWindow->initializeGL(osWindow, eglLibrary.get(), param.eglParameters, configParams);
     eglWindow->destroyGL();
     EGLWindow::Delete(&eglWindow);
     return result;
@@ -52,7 +52,8 @@ bool IsWGLConfigSupported(const PlatformParameters &param, OSWindow *osWindow)
 
     WGLWindow *wglWindow = WGLWindow::New(param.majorVersion, param.minorVersion);
     ConfigParameters configParams;
-    bool result = wglWindow->initializeGL(osWindow, openglLibrary.get(), configParams);
+    bool result =
+        wglWindow->initializeGL(osWindow, openglLibrary.get(), param.eglParameters, configParams);
     wglWindow->destroyGL();
     WGLWindow::Delete(&wglWindow);
     return result;
@@ -433,6 +434,8 @@ bool IsPlatformAvailable(const PlatformParameters &param)
                       << " because it is not available." << std::endl;
         }
 
+        // Uncomment this to print available platforms.
+        // std::cout << "Platform: " << param << " (" << paramAvailabilityCache.size() << ")\n";
         return result;
     }
 }

util/EGLPlatformParameters.h

@@ -8,32 +8,72 @@
 #ifndef UTIL_EGLPLATFORMPARAMETERS_H_
 #define UTIL_EGLPLATFORMPARAMETERS_H_
 
-#include <EGL/eglplatform.h>
+#include "util/util_gl.h"
 
-#include "util/util_export.h"
+#include <tuple>
 
-struct ANGLE_UTIL_EXPORT EGLPlatformParameters
+namespace angle
 {
-    EGLint renderer;
-    EGLint majorVersion;
-    EGLint minorVersion;
-    EGLint deviceType;
-    EGLint presentPath;
-
-    EGLPlatformParameters();
-    explicit EGLPlatformParameters(EGLint renderer);
+struct PlatformMethods;
+}  // namespace angle
+
+struct EGLPlatformParameters
+{
+    EGLPlatformParameters() = default;
+
+    explicit EGLPlatformParameters(EGLint renderer) : renderer(renderer) {}
+
     EGLPlatformParameters(EGLint renderer,
                           EGLint majorVersion,
                           EGLint minorVersion,
-                          EGLint deviceType);
+                          EGLint deviceType)
+        : renderer(renderer),
+          majorVersion(majorVersion),
+          minorVersion(minorVersion),
+          deviceType(deviceType)
+    {}
+
     EGLPlatformParameters(EGLint renderer,
                           EGLint majorVersion,
                           EGLint minorVersion,
                           EGLint deviceType,
-                          EGLint presentPath);
+                          EGLint presentPath)
+        : renderer(renderer),
+          majorVersion(majorVersion),
+          minorVersion(minorVersion),
+          deviceType(deviceType),
+          presentPath(presentPath)
+    {}
+
+    auto tie() const
+    {
+        return std::tie(renderer, majorVersion, minorVersion, deviceType, presentPath,
+                        debugLayersEnabled, contextVirtualization, platformMethods);
+    }
+
+    EGLint renderer                         = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+    EGLint majorVersion                     = EGL_DONT_CARE;
+    EGLint minorVersion                     = EGL_DONT_CARE;
+    EGLint deviceType                       = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    EGLint presentPath                      = EGL_DONT_CARE;
+    EGLint debugLayersEnabled               = EGL_DONT_CARE;
+    EGLint contextVirtualization            = EGL_DONT_CARE;
+    angle::PlatformMethods *platformMethods = nullptr;
 };
 
-ANGLE_UTIL_EXPORT bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b);
-ANGLE_UTIL_EXPORT bool operator==(const EGLPlatformParameters &a, const EGLPlatformParameters &b);
+inline bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
+{
+    return a.tie() < b.tie();
+}
+
+inline bool operator==(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
+{
+    return a.tie() == b.tie();
+}
+
+inline bool operator!=(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
+{
+    return a.tie() != b.tie();
+}
 
 #endif  // UTIL_EGLPLATFORMPARAMETERS_H_

util/EGLWindow.cpp

@@ -16,81 +16,9 @@
 #include "util/OSWindow.h"
 #include "util/system_utils.h"
 
-EGLPlatformParameters::EGLPlatformParameters()
-    : renderer(EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE),
-      majorVersion(EGL_DONT_CARE),
-      minorVersion(EGL_DONT_CARE),
-      deviceType(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE),
-      presentPath(EGL_DONT_CARE)
-{}
-
-EGLPlatformParameters::EGLPlatformParameters(EGLint renderer)
-    : renderer(renderer),
-      majorVersion(EGL_DONT_CARE),
-      minorVersion(EGL_DONT_CARE),
-      deviceType(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE),
-      presentPath(EGL_DONT_CARE)
-{}
-
-EGLPlatformParameters::EGLPlatformParameters(EGLint renderer,
-                                             EGLint majorVersion,
-                                             EGLint minorVersion,
-                                             EGLint deviceType)
-    : renderer(renderer),
-      majorVersion(majorVersion),
-      minorVersion(minorVersion),
-      deviceType(deviceType),
-      presentPath(EGL_DONT_CARE)
-{}
-
-EGLPlatformParameters::EGLPlatformParameters(EGLint renderer,
-                                             EGLint majorVersion,
-                                             EGLint minorVersion,
-                                             EGLint deviceType,
-                                             EGLint presentPath)
-    : renderer(renderer),
-      majorVersion(majorVersion),
-      minorVersion(minorVersion),
-      deviceType(deviceType),
-      presentPath(presentPath)
-{}
-
-bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
-{
-    if (a.renderer != b.renderer)
-    {
-        return a.renderer < b.renderer;
-    }
-
-    if (a.majorVersion != b.majorVersion)
-    {
-        return a.majorVersion < b.majorVersion;
-    }
-
-    if (a.minorVersion != b.minorVersion)
-    {
-        return a.minorVersion < b.minorVersion;
-    }
-
-    if (a.deviceType != b.deviceType)
-    {
-        return a.deviceType < b.deviceType;
-    }
-
-    return a.presentPath < b.presentPath;
-}
-
-bool operator==(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
-{
-    return (a.renderer == b.renderer) && (a.majorVersion == b.majorVersion) &&
-           (a.minorVersion == b.minorVersion) && (a.deviceType == b.deviceType) &&
-           (a.presentPath == b.presentPath);
-}
-
 // ConfigParameters implementation.
 ConfigParameters::ConfigParameters()
-    : platformMethods(nullptr),
-      redBits(-1),
+    : redBits(-1),
       greenBits(-1),
       blueBits(-1),
       alphaBits(-1),
@@ -114,14 +42,6 @@ void ConfigParameters::reset()
     *this = ConfigParameters();
 }
 
-// static
-bool ConfigParameters::CanShareDisplay(const ConfigParameters &a, const ConfigParameters &b)
-{
-    return a.debugLayersEnabled == b.debugLayersEnabled &&
-           a.contextVirtualization == b.contextVirtualization &&
-           a.platformMethods == b.platformMethods;
-}
-
 // GLWindowBase implementation.
 GLWindowBase::GLWindowBase(EGLint glesMajorVersion, EGLint glesMinorVersion)
     : mClientMajorVersion(glesMajorVersion), mClientMinorVersion(glesMinorVersion)
@@ -130,17 +50,14 @@ GLWindowBase::GLWindowBase(EGLint glesMajorVersion, EGLint glesMinorVersion)
 GLWindowBase::~GLWindowBase() = default;
 
 // EGLWindow implementation.
-EGLWindow::EGLWindow(EGLint glesMajorVersion,
-                     EGLint glesMinorVersion,
-                     const EGLPlatformParameters &platform)
+EGLWindow::EGLWindow(EGLint glesMajorVersion, EGLint glesMinorVersion)
     : GLWindowBase(glesMajorVersion, glesMinorVersion),
       mConfig(0),
       mDisplay(EGL_NO_DISPLAY),
       mSurface(EGL_NO_SURFACE),
       mContext(EGL_NO_CONTEXT),
       mEGLMajorVersion(0),
-      mEGLMinorVersion(0),
-      mPlatform(platform)
+      mEGLMinorVersion(0)
 {}
 
 EGLWindow::~EGLWindow()
@@ -175,11 +92,12 @@ EGLContext EGLWindow::getContext() const
 
 bool EGLWindow::initializeGL(OSWindow *osWindow,
                              angle::Library *glWindowingLibrary,
-                             const ConfigParameters &params)
+                             const EGLPlatformParameters &platformParams,
+                             const ConfigParameters &configParams)
 {
-    if (!initializeDisplay(osWindow, glWindowingLibrary, params))
+    if (!initializeDisplay(osWindow, glWindowingLibrary, platformParams))
         return false;
-    if (!initializeSurface(osWindow, glWindowingLibrary, params))
+    if (!initializeSurface(osWindow, glWindowingLibrary, configParams))
         return false;
     if (!initializeContext())
         return false;
@@ -188,10 +106,8 @@ bool EGLWindow::initializeGL(OSWindow *osWindow,
 
 bool EGLWindow::initializeDisplay(OSWindow *osWindow,
                                   angle::Library *glWindowingLibrary,
-                                  const ConfigParameters &params)
+                                  const EGLPlatformParameters &params)
 {
-    mConfigParams = params;
-
 #if defined(ANGLE_USE_UTIL_LOADER)
     PFNEGLGETPROCADDRESSPROC getProcAddress;
     glWindowingLibrary->getAs("eglGetProcAddress", &getProcAddress);
@@ -206,19 +122,19 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
 
     std::vector<EGLAttrib> displayAttributes;
     displayAttributes.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
-    displayAttributes.push_back(mPlatform.renderer);
+    displayAttributes.push_back(params.renderer);
     displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE);
-    displayAttributes.push_back(mPlatform.majorVersion);
+    displayAttributes.push_back(params.majorVersion);
     displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE);
-    displayAttributes.push_back(mPlatform.minorVersion);
+    displayAttributes.push_back(params.minorVersion);
 
-    if (mPlatform.deviceType != EGL_DONT_CARE)
+    if (params.deviceType != EGL_DONT_CARE)
     {
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
-        displayAttributes.push_back(mPlatform.deviceType);
+        displayAttributes.push_back(params.deviceType);
     }
 
-    if (mPlatform.presentPath != EGL_DONT_CARE)
+    if (params.presentPath != EGL_DONT_CARE)
     {
         const char *extensionString =
             static_cast<const char *>(eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS));
@@ -229,30 +145,28 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
         }
 
         displayAttributes.push_back(EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE);
-        displayAttributes.push_back(mPlatform.presentPath);
+        displayAttributes.push_back(params.presentPath);
     }
 
     // Set debug layer settings if requested.
-    if (mConfigParams.debugLayersEnabled.valid())
+    if (params.debugLayersEnabled != EGL_DONT_CARE)
     {
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED_ANGLE);
-        displayAttributes.push_back(mConfigParams.debugLayersEnabled.value() ? EGL_TRUE
-                                                                             : EGL_FALSE);
+        displayAttributes.push_back(params.debugLayersEnabled);
     }
 
-    if (mConfigParams.contextVirtualization.valid())
+    if (params.contextVirtualization != EGL_DONT_CARE)
     {
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_CONTEXT_VIRTUALIZATION_ANGLE);
-        displayAttributes.push_back(mConfigParams.contextVirtualization.value() ? EGL_TRUE
-                                                                                : EGL_FALSE);
+        displayAttributes.push_back(params.contextVirtualization);
     }
 
-    if (mConfigParams.platformMethods)
+    if (params.platformMethods)
     {
-        static_assert(sizeof(EGLAttrib) == sizeof(mConfigParams.platformMethods),
+        static_assert(sizeof(EGLAttrib) == sizeof(params.platformMethods),
                       "Unexpected pointer size");
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_PLATFORM_METHODS_ANGLEX);
-        displayAttributes.push_back(reinterpret_cast<EGLAttrib>(mConfigParams.platformMethods));
+        displayAttributes.push_back(reinterpret_cast<EGLAttrib>(params.platformMethods));
     }
 
     displayAttributes.push_back(EGL_NONE);
@@ -272,6 +186,7 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
         return false;
     }
 
+    mPlatform = params;
     return true;
 }
 
@@ -658,11 +573,9 @@ void GLWindowBase::Delete(GLWindowBase **window)
 }
 
 // static
-EGLWindow *EGLWindow::New(EGLint glesMajorVersion,
-                          EGLint glesMinorVersion,
-                          const EGLPlatformParameters &platform)
+EGLWindow *EGLWindow::New(EGLint glesMajorVersion, EGLint glesMinorVersion)
 {
-    return new EGLWindow(glesMajorVersion, glesMinorVersion, platform);
+    return new EGLWindow(glesMajorVersion, glesMinorVersion);
 }
 
 // static

util/EGLWindow.h

@@ -33,13 +33,6 @@ struct ANGLE_UTIL_EXPORT ConfigParameters
 
     void reset();
 
-    static bool CanShareDisplay(const ConfigParameters &a, const ConfigParameters &b);
-
-    // Display parameters.
-    Optional<bool> debugLayersEnabled;
-    Optional<bool> contextVirtualization;
-    angle::PlatformMethods *platformMethods;
-
     // Surface and Context parameters.
     int redBits;
     int greenBits;
@@ -76,22 +69,21 @@ class ANGLE_UTIL_EXPORT GLWindowBase : angle::NonCopyable
 
     virtual bool initializeGL(OSWindow *osWindow,
                               angle::Library *glWindowingLibrary,
-                              const ConfigParameters &config) = 0;
-    virtual bool isGLInitialized() const                      = 0;
-    virtual void swap()                                       = 0;
-    virtual void destroyGL()                                  = 0;
-    virtual bool makeCurrent()                                = 0;
-    virtual bool hasError() const                             = 0;
-    virtual bool setSwapInterval(EGLint swapInterval)         = 0;
+                              const EGLPlatformParameters &platformParams,
+                              const ConfigParameters &configParams) = 0;
+    virtual bool isGLInitialized() const                            = 0;
+    virtual void swap()                                             = 0;
+    virtual void destroyGL()                                        = 0;
+    virtual bool makeCurrent()                                      = 0;
+    virtual bool hasError() const                                   = 0;
+    virtual bool setSwapInterval(EGLint swapInterval)               = 0;
 
     bool isMultisample() const { return mConfigParams.multisample; }
     bool isDebugEnabled() const { return mConfigParams.debug; }
 
-    const angle::PlatformMethods *getPlatformMethods() const
-    {
-        return mConfigParams.platformMethods;
-    }
+    const angle::PlatformMethods *getPlatformMethods() const { return mPlatform.platformMethods; }
 
+    const EGLPlatformParameters &getPlatform() const { return mPlatform; }
     const ConfigParameters &getConfigParams() const { return mConfigParams; }
 
   protected:
@@ -100,20 +92,18 @@ class ANGLE_UTIL_EXPORT GLWindowBase : angle::NonCopyable
 
     EGLint mClientMajorVersion;
     EGLint mClientMinorVersion;
+    EGLPlatformParameters mPlatform;
     ConfigParameters mConfigParams;
 };
 
 class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
 {
   public:
-    static EGLWindow *New(EGLint glesMajorVersion,
-                          EGLint glesMinorVersion,
-                          const EGLPlatformParameters &platform);
+    static EGLWindow *New(EGLint glesMajorVersion, EGLint glesMinorVersion);
     static void Delete(EGLWindow **window);
 
     static EGLBoolean FindEGLConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *config);
 
-    const EGLPlatformParameters &getPlatform() const { return mPlatform; }
     EGLConfig getConfig() const;
     EGLDisplay getDisplay() const;
     EGLSurface getSurface() const;
@@ -122,7 +112,8 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
     // Internally initializes the Display, Surface and Context.
     bool initializeGL(OSWindow *osWindow,
                       angle::Library *glWindowingLibrary,
-                      const ConfigParameters &params) override;
+                      const EGLPlatformParameters &platformParams,
+                      const ConfigParameters &configParams) override;
 
     bool isGLInitialized() const override;
     void swap() override;
@@ -134,7 +125,7 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
     // Only initializes the Display.
     bool initializeDisplay(OSWindow *osWindow,
                            angle::Library *glWindowingLibrary,
-                           const ConfigParameters &params);
+                           const EGLPlatformParameters &params);
 
     // Only initializes the Surface.
     bool initializeSurface(OSWindow *osWindow,
@@ -153,9 +144,7 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
     bool isDisplayInitialized() const { return mDisplay != EGL_NO_DISPLAY; }
 
   private:
-    EGLWindow(EGLint glesMajorVersion,
-              EGLint glesMinorVersion,
-              const EGLPlatformParameters &platform);
+    EGLWindow(EGLint glesMajorVersion, EGLint glesMinorVersion);
 
     ~EGLWindow() override;
 
@@ -166,7 +155,6 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
 
     EGLint mEGLMajorVersion;
     EGLint mEGLMinorVersion;
-    EGLPlatformParameters mPlatform;
 };
 
 ANGLE_UTIL_EXPORT bool CheckExtensionExists(const char *allExtensions, const std::string &extName);

util/windows/WGLWindow.cpp

@@ -71,9 +71,9 @@ WGLWindow::~WGLWindow() {}
 // Internally initializes GL resources.
 bool WGLWindow::initializeGL(OSWindow *osWindow,
                              angle::Library *glWindowingLibrary,
-                             const ConfigParameters &params)
+                             const EGLPlatformParameters &platformParams,
+                             const ConfigParameters &configParams)
 {
-    mConfigParams = params;
     glWindowingLibrary->getAs("wglGetProcAddress", &gCurrentWGLGetProcAddress);
 
     if (!gCurrentWGLGetProcAddress)
@@ -141,7 +141,7 @@ bool WGLWindow::initializeGL(OSWindow *osWindow,
         return false;
     }
 
-    if (mConfigParams.webGLCompatibility.valid() || mConfigParams.robustResourceInit.valid())
+    if (configParams.webGLCompatibility.valid() || configParams.robustResourceInit.valid())
     {
         std::cerr << "WGLWindow does not support the requested feature set." << std::endl;
         return false;
@@ -172,6 +172,9 @@ bool WGLWindow::initializeGL(OSWindow *osWindow,
         return false;
     }
 
+    mPlatform     = platformParams;
+    mConfigParams = configParams;
+
     angle::LoadGLES(GetProcAddressWithFallback);
     return true;
 }

util/windows/WGLWindow.h

@@ -30,7 +30,8 @@ class ANGLE_UTIL_EXPORT WGLWindow : public GLWindowBase
     // Internally initializes GL resources.
     bool initializeGL(OSWindow *osWindow,
                       angle::Library *glWindowingLibrary,
-                      const ConfigParameters &params) override;
+                      const EGLPlatformParameters &platformParams,
+                      const ConfigParameters &configParams) override;
     void destroyGL() override;
     bool isGLInitialized() const override;