Only run tests that the current hardware can support.

src/tests/angle_end2end_tests.gypi

@@ -58,7 +58,9 @@
             '<(angle_path)/src/tests/egl_tests/EGLSurfaceTest.cpp',
             '<(angle_path)/src/tests/test_utils/ANGLETest.cpp',
             '<(angle_path)/src/tests/test_utils/ANGLETest.h',
+            '<(angle_path)/src/tests/test_utils/angle_test_configs.cpp',
             '<(angle_path)/src/tests/test_utils/angle_test_configs.h',
+            '<(angle_path)/src/tests/test_utils/angle_test_instantiate.cpp',
             '<(angle_path)/src/tests/test_utils/angle_test_instantiate.h',
         ],
         'angle_end2end_tests_win_sources':

src/tests/angle_perftests.gypi

@@ -25,6 +25,9 @@
             '<(angle_path)/src/tests/perf_tests/TexSubImage.cpp',
             '<(angle_path)/src/tests/perf_tests/third_party/perf/perf_test.cc',
             '<(angle_path)/src/tests/perf_tests/third_party/perf/perf_test.h',
+            '<(angle_path)/src/tests/test_utils/angle_test_configs.cpp',
+            '<(angle_path)/src/tests/test_utils/angle_test_configs.h',
+            '<(angle_path)/src/tests/test_utils/angle_test_instantiate.cpp',
             '<(angle_path)/src/tests/test_utils/angle_test_instantiate.h',
         ],
         'angle_perf_tests_win_sources':

src/tests/egl_tests/EGLContextCompatibilityTest.cpp

@@ -46,7 +46,7 @@ class EGLContextCompatibilityTest : public testing::TestWithParam<PlatformParame
 
         EGLint dispattrs[] =
         {
-            EGL_PLATFORM_ANGLE_TYPE_ANGLE, GetParam().mEGLPlatformParameters.renderer,
+            EGL_PLATFORM_ANGLE_TYPE_ANGLE, GetParam().getRenderer(),
             EGL_NONE
         };
         mDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, EGL_DEFAULT_DISPLAY, dispattrs);

src/tests/egl_tests/EGLQueryContextTest.cpp

@@ -18,14 +18,14 @@ class EGLQueryContextTest : public testing::TestWithParam<PlatformParameters>
   public:
     void SetUp() override
     {
-        int clientVersion = GetParam().mClientVersion;
+        int clientVersion = GetParam().majorVersion;
 
         PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT = reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(eglGetProcAddress("eglGetPlatformDisplayEXT"));
         EXPECT_TRUE(eglGetPlatformDisplayEXT != NULL);
 
         EGLint dispattrs[] =
         {
-            EGL_PLATFORM_ANGLE_TYPE_ANGLE, GetParam().mEGLPlatformParameters.renderer,
+            EGL_PLATFORM_ANGLE_TYPE_ANGLE, GetParam().getRenderer(),
             EGL_NONE
         };
         mDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, EGL_DEFAULT_DISPLAY, dispattrs);
@@ -96,7 +96,7 @@ TEST_P(EGLQueryContextTest, GetClientVersion)
 {
     EGLint clientVersion;
     EXPECT_TRUE(eglQueryContext(mDisplay, mContext, EGL_CONTEXT_CLIENT_VERSION, &clientVersion) != EGL_FALSE);
-    EXPECT_TRUE(clientVersion == GetParam().mClientVersion);
+    EXPECT_TRUE(clientVersion == GetParam().majorVersion);
 }
 
 TEST_P(EGLQueryContextTest, GetRenderBufferNoSurface)

src/tests/gl_tests/DiscardFramebufferEXTTest.cpp

@@ -26,7 +26,7 @@ protected:
 
 TEST_P(DiscardFramebufferEXTTest, ExtensionEnabled)
 {
-    EGLPlatformParameters platform = GetParam().mEGLPlatformParameters;
+    EGLPlatformParameters platform = GetParam().eglParameters;
 
     if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
     {

src/tests/gl_tests/FramebufferFormatsTest.cpp

@@ -77,7 +77,7 @@ class FramebufferFormatsTest : public ANGLETest
             return;
         }
 
-        GLint clientVersion = GetParam().mClientVersion;
+        int clientVersion = getClientVersion();
         if (clientVersion < minESVersion)
         {
             return;
@@ -220,7 +220,7 @@ TEST_P(FramebufferFormatsTest, RenderbufferMultisample_DEPTH32F_STENCIL8)
 TEST_P(FramebufferFormatsTest, RenderbufferMultisample_STENCIL_INDEX8)
 {
     // TODO(geofflang): Figure out how to support GLSTENCIL_INDEX8 on desktop GL
-    if (GetParam().mEGLPlatformParameters.renderer == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    if (GetParam().getRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
     {
         std::cout << "Test skipped on Desktop OpenGL." << std::endl;
         return;

src/tests/gl_tests/GLSLTest.cpp

@@ -551,7 +551,7 @@ TEST_P(GLSLTest, InvariantVaryingOut)
 
 TEST_P(GLSLTest, FrontFacingAndVarying)
 {
-    EGLPlatformParameters platform = GetParam().mEGLPlatformParameters;
+    EGLPlatformParameters platform = GetParam().eglParameters;
 
     // Disable this test on D3D11 feature level 9_3, since gl_FrontFacing isn't supported.
     if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)

src/tests/gl_tests/RendererTest.cpp

@@ -33,7 +33,7 @@ TEST_P(RendererTest, RequestedRendererCreated)
     std::string versionString = std::string(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
     std::transform(versionString.begin(), versionString.end(), versionString.begin(), ::tolower);
 
-    const EGLPlatformParameters &platform = GetParam().mEGLPlatformParameters;
+    const EGLPlatformParameters &platform = GetParam().eglParameters;
 
     // Ensure that the renderer string contains D3D11, if we requested a D3D11 renderer.
     if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
@@ -101,7 +101,7 @@ TEST_P(RendererTest, RequestedRendererCreated)
         ASSERT_TRUE(found);
     }
 
-    EGLint glesMajorVersion = GetParam().mClientVersion;
+    EGLint glesMajorVersion = GetParam().majorVersion;
 
     // Ensure that the renderer string contains GL ES 3.0, if we requested a GL ES 3.0
     if (glesMajorVersion == 3)

src/tests/perf_tests/ANGLEPerfTest.cpp

@@ -70,7 +70,7 @@ void ANGLEPerfTest::TearDown()
 
 std::string RenderTestParams::suffix() const
 {
-    switch (requestedRenderer)
+    switch (getRenderer())
     {
         case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE: return "_d3d11";
         case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE: return "_d3d9";
@@ -81,11 +81,6 @@ std::string RenderTestParams::suffix() const
     }
 }
 
-EGLint RenderTestParams::getRenderer() const
-{
-    return requestedRenderer;
-}
-
 ANGLERenderTest::ANGLERenderTest(const std::string &name, const RenderTestParams &testParams)
     : ANGLEPerfTest(name, testParams.suffix()),
       mTestParams(testParams),
@@ -104,16 +99,11 @@ ANGLERenderTest::~ANGLERenderTest()
 
 void ANGLERenderTest::SetUp()
 {
-    EGLPlatformParameters platformParams(mTestParams.requestedRenderer,
-                                         EGL_DONT_CARE,
-                                         EGL_DONT_CARE,
-                                         mTestParams.deviceType);
-
     mOSWindow = CreateOSWindow();
     mEGLWindow = new EGLWindow(mTestParams.widowWidth,
                                mTestParams.windowHeight,
-                               mTestParams.glesMajorVersion,
-                               platformParams);
+                               mTestParams.majorVersion,
+                               mTestParams.eglParameters);
     mEGLWindow->setSwapInterval(0);
 
     if (!mOSWindow->initialize(mName, mEGLWindow->getWidth(), mEGLWindow->getHeight()))

src/tests/perf_tests/ANGLEPerfTest.h

@@ -21,6 +21,7 @@
 #include "Timer.h"
 #include "common/angleutils.h"
 #include "common/debug.h"
+#include "test_utils/angle_test_configs.h"
 #include "test_utils/angle_test_instantiate.h"
 
 class Event;
@@ -52,15 +53,10 @@ class ANGLEPerfTest : public testing::Test, angle::NonCopyable
     int mNumFrames;
 };
 
-struct RenderTestParams
+struct RenderTestParams : public angle::PlatformParameters
 {
     virtual std::string suffix() const;
 
-    EGLint getRenderer() const;
-
-    EGLint requestedRenderer;
-    EGLint deviceType;
-    EGLint glesMajorVersion;
     EGLint widowWidth;
     EGLint windowHeight;
 };

src/tests/perf_tests/BufferSubData.cpp

@@ -12,6 +12,8 @@
 #include "ANGLEPerfTest.h"
 #include "shader_utils.h"
 
+using namespace angle;
+
 namespace
 {
 
@@ -20,7 +22,8 @@ struct BufferSubDataParams final : public RenderTestParams
     BufferSubDataParams()
     {
         // Common default values
-        glesMajorVersion = 2;
+        majorVersion = 2;
+        minorVersion = 0;
         widowWidth = 512;
         windowHeight = 512;
         updateSize = 3000;
@@ -336,8 +339,7 @@ void BufferSubDataBenchmark::drawBenchmark()
 BufferSubDataParams BufferUpdateD3D11Params()
 {
     BufferSubDataParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    params.eglParameters = egl_platform::D3D11();
     params.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;
@@ -347,8 +349,7 @@ BufferSubDataParams BufferUpdateD3D11Params()
 BufferSubDataParams BufferUpdateD3D9Params()
 {
     BufferSubDataParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    params.eglParameters = egl_platform::D3D9();
     params.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;
@@ -358,8 +359,7 @@ BufferSubDataParams BufferUpdateD3D9Params()
 BufferSubDataParams BufferUpdateOpenGLParams()
 {
     BufferSubDataParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
-    params.deviceType = EGL_DONT_CARE;
+    params.eglParameters = egl_platform::OPENGL();
     params.vertexType = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized = GL_FALSE;

src/tests/perf_tests/DrawCallPerf.cpp

@@ -12,6 +12,8 @@
 #include "ANGLEPerfTest.h"
 #include "shader_utils.h"
 
+using namespace angle;
+
 namespace
 {
 
@@ -25,7 +27,8 @@ struct DrawCallPerfParams final : public RenderTestParams
     // Common default options
     DrawCallPerfParams()
     {
-        glesMajorVersion = 2;
+        majorVersion = 2;
+        minorVersion = 0;
         widowWidth = 256;
         windowHeight = 256;
         iterations = 50;
@@ -44,7 +47,7 @@ struct DrawCallPerfParams final : public RenderTestParams
             strstr << "_validation_only";
         }
 
-        if (deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE)
+        if (eglParameters.deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE)
         {
             strstr << "_null";
         }
@@ -189,32 +192,28 @@ void DrawCallPerfBenchmark::drawBenchmark()
 DrawCallPerfParams DrawCallPerfD3D11Params(bool useNullDevice)
 {
     DrawCallPerfParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
-    params.deviceType = NullDeviceType(useNullDevice);
+    params.eglParameters = egl_platform::D3D11_NULL();
     return params;
 }
 
 DrawCallPerfParams DrawCallPerfD3D9Params(bool useNullDevice)
 {
     DrawCallPerfParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
-    params.deviceType = NullDeviceType(useNullDevice);
+    params.eglParameters = egl_platform::DEFAULT_NULL();
     return params;
 }
 
 DrawCallPerfParams DrawCallPerfOpenGLParams(bool useNullDevice)
 {
     DrawCallPerfParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
-    params.deviceType = NullDeviceType(useNullDevice);
+    params.eglParameters = egl_platform::D3D9_NULL();
     return params;
 }
 
 DrawCallPerfParams DrawCallPerfValidationOnly()
 {
     DrawCallPerfParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
+    params.eglParameters = egl_platform::OPENGL();
     params.iterations = 100;
     params.numTris = 0;
     params.runTimeSeconds = 5.0;

src/tests/perf_tests/EGLInitializePerf.cpp

@@ -35,7 +35,7 @@ EGLInitializePerfTest::EGLInitializePerfTest()
       mOSWindow(nullptr),
       mDisplay(EGL_NO_DISPLAY)
 {
-    auto platform = GetParam().mEGLPlatformParameters;
+    auto platform = GetParam().eglParameters;
 
     std::vector<EGLint> displayAttributes;
     displayAttributes.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);

src/tests/perf_tests/IndexConversionPerf.cpp

@@ -12,6 +12,8 @@
 #include "ANGLEPerfTest.h"
 #include "shader_utils.h"
 
+using namespace angle;
+
 namespace
 {
 
@@ -180,11 +182,11 @@ void IndexConversionPerfTest::drawBenchmark()
 IndexConversionPerfParams IndexConversionPerfD3D11Params()
 {
     IndexConversionPerfParams params;
-    params.glesMajorVersion = 2;
+    params.eglParameters = egl_platform::D3D11_NULL();
+    params.majorVersion = 2;
+    params.minorVersion = 0;
     params.widowWidth = 256;
     params.windowHeight = 256;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
     params.iterations = 15;
     params.numIndexTris = 3000;
     return params;

src/tests/perf_tests/PointSprites.cpp

@@ -14,6 +14,8 @@
 #include "shader_utils.h"
 #include "random_utils.h"
 
+using namespace angle;
+
 namespace
 {
 
@@ -22,7 +24,8 @@ struct PointSpritesParams final : public RenderTestParams
     PointSpritesParams()
     {
         // Common default params
-        glesMajorVersion = 2;
+        majorVersion = 2;
+        minorVersion = 0;
         widowWidth = 1280;
         windowHeight = 720;
         iterations = 10;
@@ -202,24 +205,21 @@ void PointSpritesBenchmark::drawBenchmark()
 PointSpritesParams D3D11Params()
 {
     PointSpritesParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    params.eglParameters = egl_platform::D3D11();
     return params;
 }
 
 PointSpritesParams D3D9Params()
 {
     PointSpritesParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    params.eglParameters = egl_platform::D3D9();
     return params;
 }
 
 PointSpritesParams OpenGLParams()
 {
     PointSpritesParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
-    params.deviceType = EGL_DONT_CARE;
+    params.eglParameters = egl_platform::OPENGL();
     return params;
 }
 

src/tests/perf_tests/TexSubImage.cpp

@@ -12,6 +12,8 @@
 #include "ANGLEPerfTest.h"
 #include "shader_utils.h"
 
+using namespace angle;
+
 namespace
 {
 
@@ -20,7 +22,8 @@ struct TexSubImageParams final : public RenderTestParams
     TexSubImageParams()
     {
         // Common default parameters
-        glesMajorVersion = 2;
+        majorVersion = 2;
+        minorVersion = 0;
         widowWidth = 512;
         windowHeight = 512;
 
@@ -271,24 +274,21 @@ void TexSubImageBenchmark::drawBenchmark()
 TexSubImageParams D3D11Params()
 {
     TexSubImageParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    params.eglParameters = egl_platform::D3D11();
     return params;
 }
 
 TexSubImageParams D3D9Params()
 {
     TexSubImageParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
-    params.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+    params.eglParameters = egl_platform::D3D9();
     return params;
 }
 
 TexSubImageParams OpenGLParams()
 {
     TexSubImageParams params;
-    params.requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
-    params.deviceType = EGL_DONT_CARE;
+    params.eglParameters = egl_platform::OPENGL();
     return params;
 }
 

src/tests/test_utils/ANGLETest.cpp

@@ -5,7 +5,7 @@
 ANGLETest::ANGLETest()
     : mEGLWindow(nullptr)
 {
-    mEGLWindow = new EGLWindow(1280, 720, GetParam().mClientVersion, GetParam().mEGLPlatformParameters);
+    mEGLWindow = new EGLWindow(1280, 720, GetParam().majorVersion, GetParam().eglParameters);
 }
 
 ANGLETest::~ANGLETest()

src/tests/test_utils/angle_test_instantiate.cpp

+//
+// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// angle_test_instantiate.cpp: Adds support for filtering parameterized
+// tests by platform, so we skip unsupported configs.
+
+#include "test_utils/angle_test_instantiate.h"
+
+#include <map>
+#include <iostream>
+
+#include "EGLWindow.h"
+#include "OSWindow.h"
+#include "test_utils/angle_test_configs.h"
+
+namespace angle
+{
+
+bool IsPlatformAvailable(const PlatformParameters &param)
+{
+    switch (param.getRenderer())
+    {
+      case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
+        break;
+
+      case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
+#ifndef ANGLE_ENABLE_D3D9
+        return false;
+#endif
+        break;
+
+      case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
+#ifndef ANGLE_ENABLE_D3D11
+        return false;
+#endif
+        break;
+
+      case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
+      case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
+#ifndef ANGLE_ENABLE_OPENGL
+        return false;
+#endif
+        break;
+
+      default:
+        UNREACHABLE();
+        break;
+    }
+
+    static std::map<PlatformParameters, bool> paramAvailabilityCache;
+    auto iter = paramAvailabilityCache.find(param);
+    if (iter != paramAvailabilityCache.end())
+    {
+        return iter->second;
+    }
+    else
+    {
+        OSWindow *osWindow = CreateOSWindow();
+        bool result = osWindow->initialize("CONFIG_TESTER", 1, 1);
+
+        if (result)
+        {
+            EGLWindow *eglWindow = new EGLWindow(1, 1, param.majorVersion, param.eglParameters);
+            result = eglWindow->initializeGL(osWindow);
+
+            eglWindow->destroyGL();
+            SafeDelete(eglWindow);
+        }
+
+        osWindow->destroy();
+        SafeDelete(osWindow);
+
+        paramAvailabilityCache[param] = result;
+
+        if (!result)
+        {
+            std::cout << "Skipping tests using configuration " << param << " because it is not available." << std::endl;
+        }
+
+        return result;
+    }
+}
+
+}

src/tests/test_utils/angle_test_instantiate.h

@@ -15,9 +15,12 @@
 namespace angle
 {
 
+struct PlatformParameters;
+
+bool IsPlatformAvailable(const PlatformParameters &param);
+
 // This functions is used to filter which tests should be registered,
-// internally it T::getRenderer() const that should be implemented for test
-// parameter types.
+// T must be or inherit from angle::PlatformParameters.
 template <typename T>
 std::vector<T> FilterTestParams(const T *params, size_t numParams)
 {
@@ -25,34 +28,9 @@ std::vector<T> FilterTestParams(const T *params, size_t numParams)
 
     for (size_t i = 0; i < numParams; i++)
     {
-        switch (params[i].getRenderer())
+        if (IsPlatformAvailable(params[i]))
         {
-          case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
             filtered.push_back(params[i]);
-            break;
-
-          case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
-#if defined(ANGLE_ENABLE_D3D9)
-            filtered.push_back(params[i]);
-#endif
-            break;
-
-          case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
-#if defined(ANGLE_ENABLE_D3D11)
-            filtered.push_back(params[i]);
-#endif
-            break;
-
-          case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
-          case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
-#if defined(ANGLE_ENABLE_OPENGL)
-            filtered.push_back(params[i]);
-#endif
-            break;
-
-          default:
-            UNREACHABLE();
-            break;
         }
     }
 

util/EGLWindow.cpp

@@ -47,6 +47,25 @@ EGLPlatformParameters::EGLPlatformParameters(EGLint renderer, EGLint majorVersio
 {
 }
 
+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;
+    }
+
+    return a.deviceType < b.deviceType;
+}
 
 EGLWindow::EGLWindow(size_t width, size_t height, EGLint glesMajorVersion, const EGLPlatformParameters &platform)
     : mDisplay(EGL_NO_DISPLAY),

util/EGLWindow.h

@@ -43,6 +43,8 @@ struct EGLPlatformParameters
     EGLPlatformParameters(EGLint renderer, EGLint majorVersion, EGLint minorVersion, EGLint deviceType);
 };
 
+bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b);
+
 class EGLWindow : angle::NonCopyable
 {
   public: