Refactor DrawCallPerfParams.

src/tests/perf_tests/BindingPerf.cpp

@@ -196,7 +196,7 @@ BindingsParams D3D9Params(AllocationStyle allocationStyle)
 BindingsParams OpenGLOrGLESParams(AllocationStyle allocationStyle)
 {
     BindingsParams params;
-    params.eglParameters   = egl_platform::OPENGL_OR_GLES(true);
+    params.eglParameters   = egl_platform::OPENGL_OR_GLES_NULL();
     params.allocationStyle = allocationStyle;
     return params;
 }

src/tests/perf_tests/BufferSubData.cpp

@@ -363,7 +363,7 @@ BufferSubDataParams BufferUpdateD3D9Params()
 BufferSubDataParams BufferUpdateOpenGLOrGLESParams()
 {
     BufferSubDataParams params;
-    params.eglParameters        = egl_platform::OPENGL_OR_GLES(false);
+    params.eglParameters        = egl_platform::OPENGL_OR_GLES();
     params.vertexType           = GL_FLOAT;
     params.vertexComponentCount = 4;
     params.vertexNormalized     = GL_FALSE;

src/tests/perf_tests/ClearPerf.cpp

@@ -179,7 +179,7 @@ ClearParams D3D11Params()
 ClearParams OpenGLOrGLESParams()
 {
     ClearParams params;
-    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
+    params.eglParameters = egl_platform::OPENGL_OR_GLES();
     return params;
 }
 

src/tests/perf_tests/DispatchComputePerf.cpp

@@ -158,7 +158,8 @@ void DispatchComputePerfBenchmark::drawBenchmark()
 DispatchComputePerfParams DispatchComputePerfOpenGLOrGLESParams(bool useNullDevice)
 {
     DispatchComputePerfParams params;
-    params.eglParameters = angle::egl_platform::OPENGL_OR_GLES(useNullDevice);
+    params.eglParameters = useNullDevice ? angle::egl_platform::OPENGL_OR_GLES_NULL()
+                                         : angle::egl_platform::OPENGL_OR_GLES();
     return params;
 }
 

src/tests/perf_tests/DrawCallPerf.cpp

@@ -180,7 +180,7 @@ void main()
     // Set the viewport
     glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
 
-    if (params.useFBO)
+    if (params.offscreen)
     {
         CreateColorFBO(getWindow()->getWidth(), getWindow()->getHeight(), &mFBOTexture, &mFBO);
     }
@@ -310,37 +310,38 @@ DrawArraysPerfParams DrawArrays(const DrawCallPerfParams &base, StateChange stat
     return params;
 }
 
-ANGLE_INSTANTIATE_TEST(
-    DrawCallPerfBenchmark,
-    DrawArrays(DrawCallPerfD3D9Params(false, false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfD3D9Params(true, false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfD3D11Params(false, false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfD3D11Params(true, false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfD3D11Params(true, true), StateChange::NoChange),
-    DrawArrays(DrawCallPerfD3D11Params(false, false), StateChange::VertexBuffer),
-    DrawArrays(DrawCallPerfD3D11Params(true, false), StateChange::VertexBuffer),
-    DrawArrays(DrawCallPerfD3D11Params(false, false), StateChange::Texture),
-    DrawArrays(DrawCallPerfD3D11Params(true, false), StateChange::Texture),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(false, false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(true, false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(true, true), StateChange::NoChange),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(false, false), StateChange::VertexBuffer),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(true, false), StateChange::VertexBuffer),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(false, false), StateChange::ManyVertexBuffers),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(true, false), StateChange::ManyVertexBuffers),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(false, false), StateChange::Texture),
-    DrawArrays(DrawCallPerfOpenGLOrGLESParams(true, false), StateChange::Texture),
-    DrawArrays(DrawCallPerfValidationOnly(), StateChange::NoChange),
-    DrawArrays(DrawCallPerfVulkanParams(false, false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfVulkanParams(true, false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfVulkanParams(false, false), StateChange::VertexBuffer),
-    DrawArrays(DrawCallPerfVulkanParams(true, false), StateChange::VertexBuffer),
-    DrawArrays(DrawCallPerfVulkanParams(false, false), StateChange::ManyVertexBuffers),
-    DrawArrays(DrawCallPerfVulkanParams(true, false), StateChange::ManyVertexBuffers),
-    DrawArrays(DrawCallPerfVulkanParams(false, false), StateChange::Texture),
-    DrawArrays(DrawCallPerfVulkanParams(true, false), StateChange::Texture),
-    DrawArrays(DrawCallPerfWGLParams(false), StateChange::NoChange),
-    DrawArrays(DrawCallPerfWGLParams(false), StateChange::VertexBuffer),
-    DrawArrays(DrawCallPerfWGLParams(false), StateChange::Texture));
+using namespace params;
+
+ANGLE_INSTANTIATE_TEST(DrawCallPerfBenchmark,
+                       DrawArrays(DrawCallD3D9(), StateChange::NoChange),
+                       DrawArrays(NullDevice(DrawCallD3D9()), StateChange::NoChange),
+                       DrawArrays(DrawCallD3D11(), StateChange::NoChange),
+                       DrawArrays(NullDevice(DrawCallD3D11()), StateChange::NoChange),
+                       DrawArrays(NullDevice(Offscreen(DrawCallD3D11())), StateChange::NoChange),
+                       DrawArrays(DrawCallD3D11(), StateChange::VertexBuffer),
+                       DrawArrays(NullDevice(DrawCallD3D11()), StateChange::VertexBuffer),
+                       DrawArrays(DrawCallD3D11(), StateChange::Texture),
+                       DrawArrays(NullDevice(DrawCallD3D11()), StateChange::Texture),
+                       DrawArrays(DrawCallOpenGL(), StateChange::NoChange),
+                       DrawArrays(NullDevice(DrawCallOpenGL()), StateChange::NoChange),
+                       DrawArrays(NullDevice(Offscreen(DrawCallOpenGL())), StateChange::NoChange),
+                       DrawArrays(DrawCallOpenGL(), StateChange::VertexBuffer),
+                       DrawArrays(NullDevice(DrawCallOpenGL()), StateChange::VertexBuffer),
+                       DrawArrays(DrawCallOpenGL(), StateChange::ManyVertexBuffers),
+                       DrawArrays(NullDevice(DrawCallOpenGL()), StateChange::ManyVertexBuffers),
+                       DrawArrays(DrawCallOpenGL(), StateChange::Texture),
+                       DrawArrays(NullDevice(DrawCallOpenGL()), StateChange::Texture),
+                       DrawArrays(DrawCallValidation(), StateChange::NoChange),
+                       DrawArrays(DrawCallVulkan(), StateChange::NoChange),
+                       DrawArrays(NullDevice(DrawCallVulkan()), StateChange::NoChange),
+                       DrawArrays(DrawCallVulkan(), StateChange::VertexBuffer),
+                       DrawArrays(NullDevice(DrawCallVulkan()), StateChange::VertexBuffer),
+                       DrawArrays(DrawCallVulkan(), StateChange::ManyVertexBuffers),
+                       DrawArrays(NullDevice(DrawCallVulkan()), StateChange::ManyVertexBuffers),
+                       DrawArrays(DrawCallVulkan(), StateChange::Texture),
+                       DrawArrays(NullDevice(DrawCallVulkan()), StateChange::Texture),
+                       DrawArrays(DrawCallWGL(), StateChange::NoChange),
+                       DrawArrays(DrawCallWGL(), StateChange::VertexBuffer),
+                       DrawArrays(DrawCallWGL(), StateChange::Texture));
 
 }  // anonymous namespace

src/tests/perf_tests/DrawCallPerfParams.cpp

@@ -26,7 +26,7 @@ DrawCallPerfParams::DrawCallPerfParams()
 #endif
     runTimeSeconds = 10.0;
     numTris        = 1;
-    useFBO         = false;
+    offscreen      = false;
 }
 
 DrawCallPerfParams::~DrawCallPerfParams() = default;
@@ -42,9 +42,9 @@ std::string DrawCallPerfParams::suffix() const
         strstr << "_validation_only";
     }
 
-    if (useFBO)
+    if (offscreen)
     {
-        strstr << "_render_to_texture";
+        strstr << "_offscreen";
     }
 
     if (eglParameters.deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE)
@@ -57,31 +57,30 @@ std::string DrawCallPerfParams::suffix() const
 
 using namespace angle::egl_platform;
 
-DrawCallPerfParams DrawCallPerfD3D11Params(bool useNullDevice, bool renderToTexture)
+namespace params
+{
+DrawCallPerfParams DrawCallD3D11()
 {
     DrawCallPerfParams params;
-    params.eglParameters = useNullDevice ? D3D11_NULL() : D3D11();
-    params.useFBO        = renderToTexture;
+    params.eglParameters = D3D11();
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfD3D9Params(bool useNullDevice, bool renderToTexture)
+DrawCallPerfParams DrawCallD3D9()
 {
     DrawCallPerfParams params;
-    params.eglParameters = useNullDevice ? D3D9_NULL() : D3D9();
-    params.useFBO        = renderToTexture;
+    params.eglParameters = D3D9();
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfOpenGLOrGLESParams(bool useNullDevice, bool renderToTexture)
+DrawCallPerfParams DrawCallOpenGL()
 {
     DrawCallPerfParams params;
-    params.eglParameters = OPENGL_OR_GLES(useNullDevice);
-    params.useFBO        = renderToTexture;
+    params.eglParameters = OPENGL_OR_GLES();
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfValidationOnly()
+DrawCallPerfParams DrawCallValidation()
 {
     DrawCallPerfParams params;
     params.eglParameters  = DEFAULT();
@@ -90,18 +89,31 @@ DrawCallPerfParams DrawCallPerfValidationOnly()
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfVulkanParams(bool useNullDevice, bool renderToTexture)
+DrawCallPerfParams DrawCallVulkan()
 {
     DrawCallPerfParams params;
-    params.eglParameters = useNullDevice ? VULKAN_NULL() : VULKAN();
-    params.useFBO        = renderToTexture;
+    params.eglParameters = VULKAN();
     return params;
 }
 
-DrawCallPerfParams DrawCallPerfWGLParams(bool renderToTexture)
+DrawCallPerfParams DrawCallWGL()
 {
     DrawCallPerfParams params;
-    params.useFBO = renderToTexture;
     params.driver = angle::GLESDriverType::SystemWGL;
     return params;
 }
+
+DrawCallPerfParams Offscreen(const DrawCallPerfParams &input)
+{
+    DrawCallPerfParams output = input;
+    output.offscreen          = true;
+    return output;
+}
+
+DrawCallPerfParams NullDevice(const DrawCallPerfParams &input)
+{
+    DrawCallPerfParams output       = input;
+    output.eglParameters.deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
+    return output;
+}
+}  // namespace params

src/tests/perf_tests/DrawCallPerfParams.h

@@ -24,14 +24,21 @@ struct DrawCallPerfParams : public RenderTestParams
 
     double runTimeSeconds;
     int numTris;
-    bool useFBO;
+    bool offscreen;
 };
 
-DrawCallPerfParams DrawCallPerfD3D11Params(bool useNullDevice, bool renderToTexture);
-DrawCallPerfParams DrawCallPerfD3D9Params(bool useNullDevice, bool renderToTexture);
-DrawCallPerfParams DrawCallPerfOpenGLOrGLESParams(bool useNullDevice, bool renderToTexture);
-DrawCallPerfParams DrawCallPerfValidationOnly();
-DrawCallPerfParams DrawCallPerfVulkanParams(bool useNullDevice, bool renderToTexture);
-DrawCallPerfParams DrawCallPerfWGLParams(bool renderToTexture);
+namespace params
+{
+DrawCallPerfParams DrawCallD3D11();
+DrawCallPerfParams DrawCallD3D9();
+DrawCallPerfParams DrawCallOpenGL();
+DrawCallPerfParams DrawCallValidation();
+DrawCallPerfParams DrawCallVulkan();
+DrawCallPerfParams DrawCallWGL();
+
+// Mixins.
+DrawCallPerfParams Offscreen(const DrawCallPerfParams &input);
+DrawCallPerfParams NullDevice(const DrawCallPerfParams &input);
+}  // namespace params
 
 #endif  // TESTS_PERF_TESTS_DRAW_CALL_PERF_PARAMS_H_

src/tests/perf_tests/DrawElementsPerf.cpp

@@ -148,7 +148,7 @@ void DrawElementsPerfBenchmark::initializeBenchmark()
     // Set the viewport
     glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
 
-    if (params.useFBO)
+    if (params.offscreen)
     {
         CreateColorFBO(getWindow()->getWidth(), getWindow()->getHeight(), &mTexture, &mFBO);
     }
@@ -237,7 +237,8 @@ DrawElementsPerfParams DrawElementsPerfOpenGLOrGLESParams(bool indexBufferChange
                                                           GLenum indexType)
 {
     DrawElementsPerfParams params;
-    params.eglParameters      = angle::egl_platform::OPENGL_OR_GLES(useNullDevice);
+    params.eglParameters = useNullDevice ? angle::egl_platform::OPENGL_OR_GLES_NULL()
+                                         : angle::egl_platform::OPENGL_OR_GLES();
     params.indexBufferChanged = indexBufferChanged;
     params.type               = indexType;
 

src/tests/perf_tests/InstancingPerf.cpp

@@ -340,7 +340,7 @@ InstancingPerfParams InstancingPerfD3D9Params()
 InstancingPerfParams InstancingPerfOpenGLOrGLESParams()
 {
     InstancingPerfParams params;
-    params.eglParameters = OPENGL_OR_GLES(false);
+    params.eglParameters = OPENGL_OR_GLES();
     return params;
 }
 

src/tests/perf_tests/InterleavedAttributeData.cpp

@@ -229,7 +229,7 @@ InterleavedAttributeDataParams D3D9Params()
 InterleavedAttributeDataParams OpenGLOrGLESParams()
 {
     InterleavedAttributeDataParams params;
-    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
+    params.eglParameters = egl_platform::OPENGL_OR_GLES();
     return params;
 }
 

src/tests/perf_tests/LinkProgramPerfTest.cpp

@@ -191,7 +191,7 @@ LinkProgramParams LinkProgramD3D9Params(TaskOption taskOption, ThreadOption thre
 LinkProgramParams LinkProgramOpenGLOrGLESParams(TaskOption taskOption, ThreadOption threadOption)
 {
     LinkProgramParams params(taskOption, threadOption);
-    params.eglParameters = OPENGL_OR_GLES(false);
+    params.eglParameters = OPENGL_OR_GLES();
     return params;
 }
 

src/tests/perf_tests/MultiviewPerf.cpp

@@ -572,17 +572,17 @@ TEST_P(MultiviewCPUBoundBenchmark, Run)
 
 ANGLE_INSTANTIATE_TEST(
     MultiviewCPUBoundBenchmark,
-    NoAcceleration(egl_platform::OPENGL_OR_GLES(false), SmallWorkload(), ExtensionName::multiview),
+    NoAcceleration(egl_platform::OPENGL_OR_GLES(), SmallWorkload(), ExtensionName::multiview),
     NoAcceleration(egl_platform::D3D11(), SmallWorkload(), ExtensionName::multiview),
     SelectViewInGeometryShader(SmallWorkload(), ExtensionName::multiview),
-    SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(false),
+    SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(),
                              SmallWorkload(),
                              ExtensionName::multiview),
     SelectViewInVertexShader(egl_platform::D3D11(), SmallWorkload(), ExtensionName::multiview),
-    NoAcceleration(egl_platform::OPENGL_OR_GLES(false), SmallWorkload(), ExtensionName::multiview2),
+    NoAcceleration(egl_platform::OPENGL_OR_GLES(), SmallWorkload(), ExtensionName::multiview2),
     NoAcceleration(egl_platform::D3D11(), SmallWorkload(), ExtensionName::multiview2),
     SelectViewInGeometryShader(SmallWorkload(), ExtensionName::multiview2),
-    SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(false),
+    SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(),
                              SmallWorkload(),
                              ExtensionName::multiview2),
     SelectViewInVertexShader(egl_platform::D3D11(), SmallWorkload(), ExtensionName::multiview2));
@@ -594,17 +594,17 @@ TEST_P(MultiviewGPUBoundBenchmark, Run)
 
 ANGLE_INSTANTIATE_TEST(
     MultiviewGPUBoundBenchmark,
-    NoAcceleration(egl_platform::OPENGL_OR_GLES(false), BigWorkload(), ExtensionName::multiview),
+    NoAcceleration(egl_platform::OPENGL_OR_GLES(), BigWorkload(), ExtensionName::multiview),
     NoAcceleration(egl_platform::D3D11(), BigWorkload(), ExtensionName::multiview),
     SelectViewInGeometryShader(BigWorkload(), ExtensionName::multiview),
-    SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(false),
+    SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(),
                              BigWorkload(),
                              ExtensionName::multiview),
     SelectViewInVertexShader(egl_platform::D3D11(), BigWorkload(), ExtensionName::multiview),
-    NoAcceleration(egl_platform::OPENGL_OR_GLES(false), BigWorkload(), ExtensionName::multiview2),
+    NoAcceleration(egl_platform::OPENGL_OR_GLES(), BigWorkload(), ExtensionName::multiview2),
     NoAcceleration(egl_platform::D3D11(), BigWorkload(), ExtensionName::multiview2),
     SelectViewInGeometryShader(BigWorkload(), ExtensionName::multiview2),
-    SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(false),
+    SelectViewInVertexShader(egl_platform::OPENGL_OR_GLES(),
                              BigWorkload(),
                              ExtensionName::multiview2),
     SelectViewInVertexShader(egl_platform::D3D11(), BigWorkload(), ExtensionName::multiview2));

src/tests/perf_tests/PointSprites.cpp

@@ -211,7 +211,7 @@ PointSpritesParams D3D9Params()
 PointSpritesParams OpenGLOrGLESParams()
 {
     PointSpritesParams params;
-    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
+    params.eglParameters = egl_platform::OPENGL_OR_GLES();
     return params;
 }
 

src/tests/perf_tests/TextureSampling.cpp

@@ -275,7 +275,7 @@ TextureSamplingParams D3D9Params()
 TextureSamplingParams OpenGLOrGLESParams()
 {
     TextureSamplingParams params;
-    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
+    params.eglParameters = egl_platform::OPENGL_OR_GLES();
     return params;
 }
 

src/tests/perf_tests/TextureUploadPerf.cpp

@@ -244,7 +244,7 @@ TextureUploadParams D3D11Params(bool webglCompat)
 TextureUploadParams OpenGLOrGLESParams(bool webglCompat)
 {
     TextureUploadParams params;
-    params.eglParameters = egl_platform::OPENGL_OR_GLES(false);
+    params.eglParameters = egl_platform::OPENGL_OR_GLES();
     params.webgl         = webglCompat;
     return params;
 }

src/tests/perf_tests/TexturesPerf.cpp

@@ -292,7 +292,7 @@ TexturesParams D3D9Params(bool webglCompat)
 TexturesParams OpenGLOrGLESParams(bool webglCompat)
 {
     TexturesParams params;
-    params.eglParameters = egl_platform::OPENGL_OR_GLES(true);
+    params.eglParameters = egl_platform::OPENGL_OR_GLES_NULL();
     params.webgl         = webglCompat;
     return params;
 }

src/tests/perf_tests/UniformsPerf.cpp

@@ -409,9 +409,9 @@ ANGLE_INSTANTIATE_TEST(UniformsBenchmark,
                        VectorUniforms(D3D11(), DataMode::REPEAT),
                        VectorUniforms(D3D11(), DataMode::UPDATE),
                        VectorUniforms(D3D11_NULL(), DataMode::UPDATE),
-                       VectorUniforms(OPENGL_OR_GLES(false), DataMode::UPDATE),
-                       VectorUniforms(OPENGL_OR_GLES(false), DataMode::REPEAT),
-                       VectorUniforms(OPENGL_OR_GLES(true), DataMode::UPDATE),
+                       VectorUniforms(OPENGL_OR_GLES(), DataMode::UPDATE),
+                       VectorUniforms(OPENGL_OR_GLES(), DataMode::REPEAT),
+                       VectorUniforms(OPENGL_OR_GLES_NULL(), DataMode::UPDATE),
                        MatrixUniforms(D3D11(), DataMode::UPDATE),
-                       MatrixUniforms(OPENGL_OR_GLES(false), DataMode::UPDATE),
+                       MatrixUniforms(OPENGL_OR_GLES(), DataMode::UPDATE),
                        VectorUniforms(D3D11_NULL(), DataMode::REPEAT, ProgramMode::MULTIPLE));

src/tests/test_utils/angle_test_configs.cpp

@@ -365,12 +365,21 @@ EGLPlatformParameters OPENGLES_NULL()
                                  EGL_DONT_CARE, EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE);
 }
 
-EGLPlatformParameters OPENGL_OR_GLES(bool useNullDevice)
+EGLPlatformParameters OPENGL_OR_GLES()
 {
 #if defined(ANGLE_PLATFORM_ANDROID)
-    return useNullDevice ? OPENGLES_NULL() : OPENGLES();
+    return OPENGLES();
 #else
-    return useNullDevice ? OPENGL_NULL() : OPENGL();
+    return OPENGL();
+#endif
+}
+
+EGLPlatformParameters OPENGL_OR_GLES_NULL()
+{
+#if defined(ANGLE_PLATFORM_ANDROID)
+    return OPENGLES_NULL();
+#else
+    return OPENGL_NULL();
 #endif
 }
 

src/tests/test_utils/angle_test_configs.h

@@ -106,7 +106,8 @@ EGLPlatformParameters OPENGLES();
 EGLPlatformParameters OPENGLES(EGLint major, EGLint minor);
 EGLPlatformParameters OPENGLES_NULL();
 
-EGLPlatformParameters OPENGL_OR_GLES(bool useNullDevice);
+EGLPlatformParameters OPENGL_OR_GLES();
+EGLPlatformParameters OPENGL_OR_GLES_NULL();
 
 EGLPlatformParameters VULKAN();
 EGLPlatformParameters VULKAN_NULL();