Allow tests to pick ANGLE features.

include/platform/FeaturesVk.h

@@ -238,6 +238,14 @@ struct FeaturesVk : FeatureSetBase
         "supports_swapchain_colorspace", FeatureCategory::VulkanFeatures,
         "VkDevice supports the VK_EXT_swapchain_colorspace extension", &members,
         "http://anglebug.com/2514"};
+
+    // Whether to use ANGLE's deferred command graph. http://anglebug.com/4029
+    Feature commandGraph = {
+        "command_graph",
+        FeatureCategory::VulkanFeatures,
+        "Use ANGLE's Vulkan deferred command graph.",
+        &members,
+    };
 };
 
 inline FeaturesVk::FeaturesVk()  = default;

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -1479,6 +1479,8 @@ void RendererVk::initFeatures(const ExtensionNameList &deviceExtensionNames)
         IsPixel2(mPhysicalDeviceProperties.vendorID, mPhysicalDeviceProperties.deviceID) ||
             IsPixel1XL(mPhysicalDeviceProperties.vendorID, mPhysicalDeviceProperties.deviceID));
 
+    ANGLE_FEATURE_CONDITION((&mFeatures), commandGraph, true);
+
     angle::PlatformMethods *platform = ANGLEPlatformCurrent();
     platform->overrideFeaturesVk(platform, &mFeatures);
 }

src/tests/test_utils/angle_test_configs.cpp

@@ -187,6 +187,15 @@ std::ostream &operator<<(std::ostream &stream, const PlatformParameters &pp)
         stream << "_NoVirtual";
     }
 
+    if (pp.eglParameters.commandGraphFeature == EGL_FALSE)
+    {
+        stream << "_NoCommandGraph";
+    }
+    else if (pp.eglParameters.commandGraphFeature == EGL_TRUE)
+    {
+        stream << "_CommandGraph";
+    }
+
     return stream;
 }
 

src/tests/test_utils/angle_test_configs.h

@@ -206,6 +206,13 @@ inline PlatformParameters WithNoFixture(const PlatformParameters &params)
     withNoFixture.noFixture          = true;
     return withNoFixture;
 }
+
+inline PlatformParameters WithNoCommandGraph(const PlatformParameters &params)
+{
+    PlatformParameters withNoCommandGraph                = params;
+    withNoCommandGraph.eglParameters.commandGraphFeature = EGL_FALSE;
+    return withNoCommandGraph;
+}
 }  // namespace angle
 
 #endif  // ANGLE_TEST_CONFIGS_H_

util/EGLPlatformParameters.h

@@ -58,6 +58,7 @@ struct EGLPlatformParameters
     EGLint presentPath                      = EGL_DONT_CARE;
     EGLint debugLayersEnabled               = EGL_DONT_CARE;
     EGLint contextVirtualization            = EGL_DONT_CARE;
+    EGLint commandGraphFeature              = EGL_DONT_CARE;
     angle::PlatformMethods *platformMethods = nullptr;
 };
 

util/EGLWindow.cpp

@@ -120,6 +120,9 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
     angle::LoadEGL(getProcAddress);
 #endif  // defined(ANGLE_USE_UTIL_LOADER)
 
+    const char *extensionString =
+        static_cast<const char *>(eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS));
+
     std::vector<EGLAttrib> displayAttributes;
     displayAttributes.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
     displayAttributes.push_back(params.renderer);
@@ -136,8 +139,6 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
 
     if (params.presentPath != EGL_DONT_CARE)
     {
-        const char *extensionString =
-            static_cast<const char *>(eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS));
         if (strstr(extensionString, "EGL_ANGLE_experimental_present_path") == nullptr)
         {
             destroyGL();
@@ -169,6 +170,48 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
         displayAttributes.push_back(reinterpret_cast<EGLAttrib>(params.platformMethods));
     }
 
+    std::vector<const char *> disabledFeatureOverrides;
+    std::vector<const char *> enabledFeatureOverrides;
+
+    if (params.commandGraphFeature == EGL_TRUE)
+    {
+        enabledFeatureOverrides.push_back("command_graph");
+    }
+    else if (params.commandGraphFeature == EGL_FALSE)
+    {
+        disabledFeatureOverrides.push_back("command_graph");
+    }
+
+    if (!disabledFeatureOverrides.empty())
+    {
+        if (strstr(extensionString, "EGL_ANGLE_feature_control") == nullptr)
+        {
+            std::cout << "Missing EGL_ANGLE_feature_control.\n";
+            destroyGL();
+            return false;
+        }
+
+        disabledFeatureOverrides.push_back(nullptr);
+
+        displayAttributes.push_back(EGL_FEATURE_OVERRIDES_DISABLED_ANGLE);
+        displayAttributes.push_back(reinterpret_cast<EGLAttrib>(disabledFeatureOverrides.data()));
+    }
+
+    if (!enabledFeatureOverrides.empty())
+    {
+        if (strstr(extensionString, "EGL_ANGLE_feature_control") == nullptr)
+        {
+            std::cout << "Missing EGL_ANGLE_feature_control.\n";
+            destroyGL();
+            return false;
+        }
+
+        enabledFeatureOverrides.push_back(nullptr);
+
+        displayAttributes.push_back(EGL_FEATURE_OVERRIDES_ENABLED_ANGLE);
+        displayAttributes.push_back(reinterpret_cast<EGLAttrib>(enabledFeatureOverrides.data()));
+    }
+
     displayAttributes.push_back(EGL_NONE);
 
     mDisplay = eglGetPlatformDisplay(EGL_PLATFORM_ANGLE_ANGLE,