Ensure Features* descriptions stay up to date

extensions/EGL_ANGLE_feature_control.txt

@@ -74,6 +74,7 @@ New Tokens
         EGL_FEATURE_DESCRIPTION_ANGLE   0x3462
         EGL_FEATURE_BUG_ANGLE           0x3463
         EGL_FEATURE_STATUS_ANGLE        0x3464
+        EGL_FEATURE_CONDITION_ANGLE     0x3468
 
     Accepted as a queried <attribute> in eglQueryDisplayAttribANGLE
 
@@ -122,6 +123,9 @@ Add the following to the end of section 3.3 "EGL Queries":
     with corresponding indices to the array of names. Each string has
     the value "enabled" if the feature is currently enabled, or
     "disabled" if the feature is currently disabled.
+        The EGL_FEATURE_CONDITION_ANGLE array contains strings that
+    describe to the condition that sets the corresponding value in
+    the EGL_FEATURE_STATUS_ANGLE array.
 
     Errors
 

include/EGL/eglext_angle.h

@@ -224,6 +224,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncValuesCHROMIUM(EGLDisplay dpy,
 #define EGL_FEATURE_COUNT_ANGLE 0x3465
 #define EGL_FEATURE_OVERRIDES_ENABLED_ANGLE 0x3466
 #define EGL_FEATURE_OVERRIDES_DISABLED_ANGLE 0x3467
+#define EGL_FEATURE_CONDITION_ANGLE 0x3468
 typedef const char *(EGLAPIENTRYP PFNEGLQUERYSTRINGIANGLEPROC) (EGLDisplay dpy, EGLint name, EGLint index);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDISPLAYATTRIBANGLEPROC) (EGLDisplay dpy, EGLint attribute, EGLAttrib *value);
 #ifdef EGL_EGLEXT_PROTOTYPES

include/platform/Feature.h

@@ -13,6 +13,10 @@
 #include <string>
 #include <vector>
 
+#define ANGLE_FEATURE_CONDITION(set, feature, cond) \
+    set->feature.enabled   = cond;                  \
+    set->feature.condition = ANGLE_STRINGIFY(cond);
+
 namespace angle
 {
 
@@ -110,6 +114,9 @@ struct Feature
     // Whether the workaround is enabled or not. Determined by heuristics like vendor ID and
     // version, but may be overriden to any value.
     bool enabled = false;
+
+    // A stingified version of the condition used to set 'enabled'. ie "IsNvidia() && IsApple()"
+    const char *condition;
 };
 
 inline Feature::Feature(const Feature &other) = default;
@@ -118,7 +125,12 @@ inline Feature::Feature(const char *name,
                         const char *description,
                         FeatureMap *const mapPtr,
                         const char *bug = "")
-    : name(name), category(category), description(description), bug(bug), enabled(false)
+    : name(name),
+      category(category),
+      description(description),
+      bug(bug),
+      enabled(false),
+      condition(nullptr)
 {
     if (mapPtr != nullptr)
     {

include/platform/FeaturesVk.h

@@ -49,8 +49,7 @@ struct FeaturesVk : FeatureSetBase
     // to have a bug where the last region is ignored.
     Feature extraCopyBufferRegion = {
         "extra_copy_buffer_region", FeatureCategory::VulkanWorkarounds,
-        "Windows Intel driver seems to have a bug where the last copy region in "
-        "vkCmdCopyBuffer is ignored",
+        "Some drivers seem to have a bug where the last copy region in vkCmdCopyBuffer is ignored",
         &members};
 
     // This flag is added for the sole purpose of end2end tests, to test the correctness
@@ -64,8 +63,7 @@ struct FeaturesVk : FeatureSetBase
     // Tracked in http://anglebug.com/2970.
     Feature clampPointSize = {
         "clamp_point_size", FeatureCategory::VulkanWorkarounds,
-        "On some NVIDIA drivers, the point size range reported from the API is "
-        "inconsistent with the actual behavior",
+        "The point size range reported from the API is inconsistent with the actual behavior",
         &members, "http://anglebug.com/2970"};
 
     // On some android devices, the memory barrier between the compute shader that converts vertex
@@ -73,8 +71,8 @@ struct FeaturesVk : FeatureSetBase
     // to perform a flush after the conversion.  http://anglebug.com/3016
     Feature flushAfterVertexConversion = {
         "flush_after_vertex_conversion", FeatureCategory::VulkanWorkarounds,
-        "On some android devices, the memory barrier between the compute shader that converts "
-        "vertex attributes and the vertex shader that reads from it is ineffective",
+        "The memory barrier between the compute shader that converts vertex attributes and the "
+        "vertex shader that reads from it is ineffective",
         &members, "http://anglebug.com/3016"};
 
     // Whether the VkDevice supports the VK_KHR_incremental_present extension, on which the
@@ -88,8 +86,7 @@ struct FeaturesVk : FeatureSetBase
     // textures.
     Feature forceCPUPathForCubeMapCopy = {
         "force_cpu_path_for_cube_map_copy", FeatureCategory::VulkanWorkarounds,
-        "Some Intel Windows drivers have an issue with creating single-layer "
-        "views on cube map textures",
+        "Some drivers have an issue with creating single-layer views on cube map textures",
         &members};
 
     // Whether the VkDevice supports the VK_ANDROID_external_memory_android_hardware_buffer
@@ -128,15 +125,13 @@ struct FeaturesVk : FeatureSetBase
     // VK_PRESENT_MODE_FIFO_KHR causes random timeouts on Linux Intel. http://anglebug.com/3153
     Feature disableFifoPresentMode = {
         "disable_fifo_present_mode", FeatureCategory::VulkanWorkarounds,
-        "On Linux Intel, VK_PRESENT_MODE_FIFO_KHR causes random timeouts", &members,
-        "http://anglebug.com/3153"};
+        "VK_PRESENT_MODE_FIFO_KHR causes random timeouts", &members, "http://anglebug.com/3153"};
 
     // On Qualcomm, a bug is preventing us from using loadOp=Clear with inline commands in the
     // render pass.  http://anglebug.com/2361
     Feature restartRenderPassAfterLoadOpClear = {
         "restart_render_pass_after_load_op_clear", FeatureCategory::VulkanWorkarounds,
-        "On Qualcomm, a bug is preventing us from using loadOp=Clear with inline "
-        "commands in the render pass",
+        "A bug is preventing us from using loadOp=Clear with inline commands in the render pass",
         &members, "http://anglebug.com/2361"};
 
     // On Qualcomm, gaps in bound descriptor set indices causes the post-gap sets to misbehave.
@@ -145,35 +140,34 @@ struct FeaturesVk : FeatureSetBase
     // unused descriptor set to work around this issue.  http://anglebug.com/2727
     Feature bindEmptyForUnusedDescriptorSets = {
         "bind_empty_for_unused_descriptor_sets", FeatureCategory::VulkanWorkarounds,
-        "On Qualcomm, gaps in bound descriptor set indices causes the post-gap sets to misbehave",
-        &members, "http://anglebug.com/2727"};
+        "Gaps in bound descriptor set indices causes the post-gap sets to misbehave", &members,
+        "http://anglebug.com/2727"};
 
     // When the scissor is (0,0,0,0) on Windows Intel, the driver acts as if the scissor was
     // disabled.  Work-around this by setting the scissor to just outside of the render area
     // (e.g. (renderArea.x, renderArea.y, 1, 1)). http://anglebug.com/3407
     Feature forceNonZeroScissor = {
         "force_non_zero_scissor", FeatureCategory::VulkanWorkarounds,
-        "On Windows Intel, when the scissor is (0,0,0,0), the driver acts as if the "
-        "scissor was disabled",
-        &members, "http://anglebug.com/3407"};
+        "When the scissor is (0,0,0,0), the driver acts as if the scissor was disabled", &members,
+        "http://anglebug.com/3407"};
 
     // OES_depth_texture is a commonly expected feature on Android. However it
     // requires that D16_UNORM support texture filtering
     // (e.g. VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) and some devices
     // do not. Work-around this by setting saying D16_UNORM supports filtering
     // anyway.
-    Feature forceD16TexFilter = {"force_D16_texture_filter", FeatureCategory::VulkanWorkarounds,
-                                 "On some Android devices, VK_FORMAT_D16_UNORM does not support "
-                                 "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, "
-                                 "which prevents OES_depth_texture from being supported.",
-                                 &members, "http://anglebug.com/3452"};
+    Feature forceD16TexFilter = {
+        "force_D16_texture_filter", FeatureCategory::VulkanWorkarounds,
+        "VK_FORMAT_D16_UNORM does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, "
+        "which prevents OES_depth_texture from being supported.",
+        &members, "http://anglebug.com/3452"};
 
     // On some android devices, vkCmdBlitImage with flipped coordinates blits incorrectly.  This
     // workaround makes sure this path is avoided.  http://anglebug.com/3498
     Feature disableFlippingBlitWithCommand = {
         "disable_flipping_blit_with_command", FeatureCategory::VulkanWorkarounds,
-        "On some android devices, vkCmdBlitImage with flipped coordinates blits incorrectly.",
-        &members, "http://anglebug.com/3498"};
+        "vkCmdBlitImage with flipped coordinates blits incorrectly.", &members,
+        "http://anglebug.com/3498"};
 
     // On platform with Intel or AMD GPU, a window resizing would not trigger the vulkan driver to
     // return VK_ERROR_OUT_OF_DATE on swapchain present.  Work-around by query current window extent
@@ -181,9 +175,8 @@ struct FeaturesVk : FeatureSetBase
     // http://anglebug.com/3623, http://anglebug.com/3624, http://anglebug.com/3625
     Feature perFrameWindowSizeQuery = {
         "per_frame_window_size_query", FeatureCategory::VulkanWorkarounds,
-        "On platform with Intel or AMD gpu, vulkan swapchain is not returning VK_ERROR_OUT_OF_DATE"
-        "when window resizing",
-        &members, "http://anglebug.com/3623, http://anglebug.com/3624, http://anglebug.com/3625"};
+        "Vulkan swapchain is not returning VK_ERROR_OUT_OF_DATE when window resizing", &members,
+        "http://anglebug.com/3623, http://anglebug.com/3624, http://anglebug.com/3625"};
 
     // On Pixel1XL and Pixel2, reset a vkCommandBuffer seems to have side effects on binding
     // descriptor sets to it afterwards, Work-around by keep using transient vkCommandBuffer on
@@ -191,22 +184,22 @@ struct FeaturesVk : FeatureSetBase
     // http://b/135763283
     Feature transientCommandBuffer = {
         "transient_command_buffer", FeatureCategory::VulkanWorkarounds,
-        "On Pixel2, keep using transient vkCommandBuffer to work around driver issue in reseting"
+        "Keep using transient vkCommandBuffer to work around driver issue in reseting"
         "vkCommandBuffer",
         &members, "http://b/135763283"};
 
     // Seamful cube map emulation misbehaves on the AMD windows driver, so it's disallowed.
     Feature disallowSeamfulCubeMapEmulation = {
         "disallow_seamful_cube_map_emulation", FeatureCategory::VulkanWorkarounds,
-        "Seamful cube map emulation misbehaves on the AMD windows driver, so it's disallowed",
-        &members, "http://anglebug.com/3243"};
+        "Seamful cube map emulation misbehaves on some drivers, so it's disallowed", &members,
+        "http://anglebug.com/3243"};
 
     // Qualcomm shader compiler doesn't support sampler arrays as parameters, so
     // revert to old RewriteStructSamplers behavior, which produces fewer.
     Feature forceOldRewriteStructSamplers = {
         "force_old_rewrite_struct_samplers", FeatureCategory::VulkanWorkarounds,
-        "Qualcomm shader compiler doesn't support sampler arrays as parameters, so "
-        "revert to old RewriteStructSamplers behavior, which produces fewer.",
+        "Some shader compilers don't support sampler arrays as parameters, so revert to old "
+        "RewriteStructSamplers behavior, which produces fewer.",
         &members, "http://anglebug.com/2703"};
 };
 

include/platform/FrontendFeatures.h

@@ -34,14 +34,14 @@ struct FrontendFeatures : angle::FeatureSetBase
     angle::Feature disableProgramCachingForTransformFeedback = {
         "disable_program_caching_for_transform_feedback",
         angle::FeatureCategory::FrontendWorkarounds,
-        "On Qualcomm GPUs, program binaries don't contain transform feedback varyings", &members};
+        "On some GPUs, program binaries don't contain transform feedback varyings", &members};
 
     // On Windows Intel OpenGL drivers TexImage sometimes seems to interact with the Framebuffer.
     // Flaky crashes can occur unless we sync the Framebuffer bindings. The workaround is to add
     // Framebuffer binding dirty bits to TexImage updates. See http://anglebug.com/2906
     angle::Feature syncFramebufferBindingsOnTexImage = {
         "sync_framebuffer_bindings_on_tex_image", angle::FeatureCategory::FrontendWorkarounds,
-        "On Windows Intel OpenGL drivers TexImage sometimes seems to interact "
+        "On some drivers TexImage sometimes seems to interact "
         "with the Framebuffer",
         &members};
 

src/libANGLE/Display.cpp

@@ -1389,8 +1389,8 @@ void Display::initVendorString()
 void Display::initializeFrontendFeatures()
 {
     // Enable on all Impls
-    mFrontendFeatures.loseContextOnOutOfMemory.enabled          = true;
-    mFrontendFeatures.scalarizeVecAndMatConstructorArgs.enabled = true;
+    ANGLE_FEATURE_CONDITION((&mFrontendFeatures), loseContextOnOutOfMemory, true)
+    ANGLE_FEATURE_CONDITION((&mFrontendFeatures), scalarizeVecAndMatConstructorArgs, true)
 
     mImplementation->initializeFrontendFeatures(&mFrontendFeatures);
 
@@ -1543,6 +1543,9 @@ const char *Display::queryStringi(const EGLint name, const EGLint index)
         case EGL_FEATURE_STATUS_ANGLE:
             result = angle::FeatureStatusToString(mFeatures[index]->enabled);
             break;
+        case EGL_FEATURE_CONDITION_ANGLE:
+            result = mFeatures[index]->condition;
+            break;
         default:
             UNREACHABLE();
             return nullptr;

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

@@ -2382,84 +2382,91 @@ void InitializeFeatures(const Renderer11DeviceCaps &deviceCaps,
                         const DXGI_ADAPTER_DESC &adapterDesc,
                         angle::FeaturesD3D *features)
 {
-    bool is9_3 = (deviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3);
+    bool isNvidia                  = IsNvidia(adapterDesc.VendorId);
+    bool isIntel                   = IsIntel(adapterDesc.VendorId);
+    bool isSkylake                 = false;
+    bool isBroadwell               = false;
+    bool isHaswell                 = false;
+    bool isAMD                     = IsAMD(adapterDesc.VendorId);
+    bool isFeatureLevel9_3         = (deviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3);
+    IntelDriverVersion capsVersion = IntelDriverVersion(0);
+    if (isIntel)
+    {
+        capsVersion = d3d11_gl::GetIntelDriverVersion(deviceCaps.driverVersion);
 
-    features->mrtPerfWorkaround.enabled                = true;
-    features->setDataFasterThanImageUpload.enabled     = true;
-    features->zeroMaxLodWorkaround.enabled             = is9_3;
-    features->useInstancedPointSpriteEmulation.enabled = is9_3;
+        isSkylake   = IsSkylake(adapterDesc.DeviceId);
+        isBroadwell = IsBroadwell(adapterDesc.DeviceId);
+        isHaswell   = IsHaswell(adapterDesc.DeviceId);
+    }
 
-    // TODO(jmadill): Narrow problematic driver range.
-    if (IsNvidia(adapterDesc.VendorId))
+    if (isNvidia)
     {
-        if (deviceCaps.driverVersion.valid())
+        // TODO(jmadill): Narrow problematic driver range.
+        bool driverVersionValid = deviceCaps.driverVersion.valid();
+        if (driverVersionValid)
         {
             WORD part1 = HIWORD(deviceCaps.driverVersion.value().LowPart);
             WORD part2 = LOWORD(deviceCaps.driverVersion.value().LowPart);
 
             // Disable the workaround to fix a second driver bug on newer NVIDIA.
-            features->depthStencilBlitExtraCopy.enabled = (part1 <= 13u && part2 < 6881);
+            ANGLE_FEATURE_CONDITION(
+                features, depthStencilBlitExtraCopy,
+                (part1 <= 13u && part2 < 6881) && isNvidia && driverVersionValid)
         }
         else
         {
-            features->depthStencilBlitExtraCopy.enabled = true;
+            ANGLE_FEATURE_CONDITION(features, depthStencilBlitExtraCopy,
+                                    isNvidia && !driverVersionValid)
         }
     }
 
+    ANGLE_FEATURE_CONDITION(features, mrtPerfWorkaround, true)
+    ANGLE_FEATURE_CONDITION(features, zeroMaxLodWorkaround, isFeatureLevel9_3)
+    ANGLE_FEATURE_CONDITION(features, useInstancedPointSpriteEmulation, isFeatureLevel9_3)
+
     // TODO(jmadill): Disable workaround when we have a fixed compiler DLL.
-    features->expandIntegerPowExpressions.enabled = true;
+    ANGLE_FEATURE_CONDITION(features, expandIntegerPowExpressions, true)
 
-    features->flushAfterEndingTransformFeedback.enabled = IsNvidia(adapterDesc.VendorId);
-    features->getDimensionsIgnoresBaseLevel.enabled     = IsNvidia(adapterDesc.VendorId);
-    features->skipVSConstantRegisterZero.enabled        = IsNvidia(adapterDesc.VendorId);
-    features->forceAtomicValueResolution.enabled        = IsNvidia(adapterDesc.VendorId);
+    ANGLE_FEATURE_CONDITION(features, flushAfterEndingTransformFeedback, isNvidia)
+    ANGLE_FEATURE_CONDITION(features, getDimensionsIgnoresBaseLevel, isNvidia)
+    ANGLE_FEATURE_CONDITION(features, skipVSConstantRegisterZero, isNvidia)
+    ANGLE_FEATURE_CONDITION(features, forceAtomicValueResolution, isNvidia)
 
-    if (IsIntel(adapterDesc.VendorId))
-    {
-        IntelDriverVersion capsVersion = d3d11_gl::GetIntelDriverVersion(deviceCaps.driverVersion);
+    ANGLE_FEATURE_CONDITION(features, preAddTexelFetchOffsets, isIntel)
+    ANGLE_FEATURE_CONDITION(features, useSystemMemoryForConstantBuffers, isIntel)
 
-        features->preAddTexelFetchOffsets.enabled           = true;
-        features->useSystemMemoryForConstantBuffers.enabled = true;
-        features->disableB5G6R5Support.enabled          = capsVersion < IntelDriverVersion(4539);
-        features->addDummyTextureNoRenderTarget.enabled = capsVersion < IntelDriverVersion(4815);
-        if (IsSkylake(adapterDesc.DeviceId))
-        {
-            features->callClearTwice.enabled    = capsVersion < IntelDriverVersion(4771);
-            features->emulateIsnanFloat.enabled = capsVersion < IntelDriverVersion(4542);
-        }
-        else if (IsBroadwell(adapterDesc.DeviceId) || IsHaswell(adapterDesc.DeviceId))
-        {
-            features->rewriteUnaryMinusOperator.enabled = capsVersion < IntelDriverVersion(4624);
+    ANGLE_FEATURE_CONDITION(features, callClearTwice,
+                            isIntel && isSkylake && capsVersion < IntelDriverVersion(4771))
+    ANGLE_FEATURE_CONDITION(features, emulateIsnanFloat,
+                            isIntel && isSkylake && capsVersion < IntelDriverVersion(4542))
+    ANGLE_FEATURE_CONDITION(
+        features, rewriteUnaryMinusOperator,
+        isIntel && (isBroadwell || isHaswell) && capsVersion < IntelDriverVersion(4624))
 
-            // Haswell drivers occasionally corrupt (small?) (vertex?) texture data uploads.
-            features->setDataFasterThanImageUpload.enabled = false;
-        }
-    }
+    ANGLE_FEATURE_CONDITION(features, addDummyTextureNoRenderTarget,
+                            isIntel && capsVersion < IntelDriverVersion(4815))
 
-    if (IsAMD(adapterDesc.VendorId))
-    {
-        features->disableB5G6R5Support.enabled = true;
-    }
+    // Haswell drivers occasionally corrupt (small?) (vertex?) texture data uploads.
+    ANGLE_FEATURE_CONDITION(features, setDataFasterThanImageUpload, !(isBroadwell || isHaswell))
 
-    // TODO(jmadill): Disable when we have a fixed driver version.
-    features->emulateTinyStencilTextures.enabled = IsAMD(adapterDesc.VendorId);
+    ANGLE_FEATURE_CONDITION(features, disableB5G6R5Support,
+                            (isIntel && capsVersion < IntelDriverVersion(4539)) || isAMD)
 
+    // TODO(jmadill): Disable when we have a fixed driver version.
     // The tiny stencil texture workaround involves using CopySubresource or UpdateSubresource on a
     // depth stencil texture.  This is not allowed until feature level 10.1 but since it is not
     // possible to support ES3 on these devices, there is no need for the workaround to begin with
     // (anglebug.com/1572).
-    if (deviceCaps.featureLevel < D3D_FEATURE_LEVEL_10_1)
-    {
-        features->emulateTinyStencilTextures.enabled = false;
-    }
+    ANGLE_FEATURE_CONDITION(features, emulateTinyStencilTextures,
+                            isAMD && !(deviceCaps.featureLevel < D3D_FEATURE_LEVEL_10_1))
 
     // If the VPAndRTArrayIndexFromAnyShaderFeedingRasterizer feature is not available, we have to
     // select the viewport / RT array index in the geometry shader.
-    features->selectViewInGeometryShader.enabled =
-        (deviceCaps.supportsVpRtIndexWriteFromVertexShader == false);
+    ANGLE_FEATURE_CONDITION(features, selectViewInGeometryShader,
+                            !deviceCaps.supportsVpRtIndexWriteFromVertexShader)
 
     // Never clear for robust resource init.  This matches Chrome's texture clearning behaviour.
-    features->allowClearForRobustResourceInit.enabled = false;
+    ANGLE_FEATURE_CONDITION(features, allowClearForRobustResourceInit, false)
 
     // Call platform hooks for testing overrides.
     auto *platform = ANGLEPlatformCurrent();

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

@@ -805,15 +805,15 @@ void MakeValidSize(bool isImage,
 
 void InitializeFeatures(angle::FeaturesD3D *features)
 {
-    features->mrtPerfWorkaround.enabled                = true;
-    features->setDataFasterThanImageUpload.enabled     = false;
-    features->useInstancedPointSpriteEmulation.enabled = false;
+    ANGLE_FEATURE_CONDITION(features, mrtPerfWorkaround, true)
+    ANGLE_FEATURE_CONDITION(features, setDataFasterThanImageUpload, false)
+    ANGLE_FEATURE_CONDITION(features, useInstancedPointSpriteEmulation, false)
 
     // TODO(jmadill): Disable workaround when we have a fixed compiler DLL.
-    features->expandIntegerPowExpressions.enabled = true;
+    ANGLE_FEATURE_CONDITION(features, expandIntegerPowExpressions, true)
 
     // Never clear for robust resource init.  This matches Chrome's texture clearning behaviour.
-    features->allowClearForRobustResourceInit.enabled = false;
+    ANGLE_FEATURE_CONDITION(features, allowClearForRobustResourceInit, false)
 
     // Call platform hooks for testing overrides.
     auto *platform = ANGLEPlatformCurrent();

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -1245,131 +1245,99 @@ gl::Version RendererVk::getMaxConformantESVersion() const
 
 void RendererVk::initFeatures(const ExtensionNameList &deviceExtensionNames)
 {
+    bool isAMD      = IsAMD(mPhysicalDeviceProperties.vendorID);
+    bool isIntel    = IsIntel(mPhysicalDeviceProperties.vendorID);
+    bool isNvidia   = IsNvidia(mPhysicalDeviceProperties.vendorID);
+    bool isQualcomm = IsQualcomm(mPhysicalDeviceProperties.vendorID);
+
     // Use OpenGL line rasterization rules by default.
     // TODO(jmadill): Fix Android support. http://anglebug.com/2830
-#if defined(ANGLE_PLATFORM_ANDROID)
-    mFeatures.basicGLLineRasterization.enabled = false;
-#else
-    mFeatures.basicGLLineRasterization.enabled = true;
-#endif  // defined(ANGLE_PLATFORM_ANDROID)
+    ANGLE_FEATURE_CONDITION((&mFeatures), basicGLLineRasterization, !IsAndroid())
 
-    if ((mPhysicalDeviceProperties.apiVersion >= VK_MAKE_VERSION(1, 1, 0)) ||
-        ExtensionFound(VK_KHR_MAINTENANCE1_EXTENSION_NAME, deviceExtensionNames))
-    {
-        // TODO(lucferron): Currently disabled on Intel only since many tests are failing and need
-        // investigation. http://anglebug.com/2728
-        mFeatures.flipViewportY.enabled = !IsIntel(mPhysicalDeviceProperties.vendorID);
-    }
+    // TODO(lucferron): Currently disabled on Intel only since many tests are failing and need
+    // investigation. http://anglebug.com/2728
+    ANGLE_FEATURE_CONDITION(
+        (&mFeatures), flipViewportY,
+        !IsIntel(mPhysicalDeviceProperties.vendorID) &&
+                (mPhysicalDeviceProperties.apiVersion >= VK_MAKE_VERSION(1, 1, 0)) ||
+            ExtensionFound(VK_KHR_MAINTENANCE1_EXTENSION_NAME, deviceExtensionNames))
 
-#ifdef ANGLE_PLATFORM_WINDOWS
     // http://anglebug.com/2838
-    mFeatures.extraCopyBufferRegion.enabled = IsIntel(mPhysicalDeviceProperties.vendorID);
+    ANGLE_FEATURE_CONDITION((&mFeatures), extraCopyBufferRegion, IsWindows() && isIntel)
 
     // http://anglebug.com/3055
-    mFeatures.forceCPUPathForCubeMapCopy.enabled = IsIntel(mPhysicalDeviceProperties.vendorID);
-#endif
-
-    angle::PlatformMethods *platform = ANGLEPlatformCurrent();
-    platform->overrideFeaturesVk(platform, &mFeatures);
+    ANGLE_FEATURE_CONDITION((&mFeatures), forceCPUPathForCubeMapCopy, IsWindows() && isIntel)
 
     // Work around incorrect NVIDIA point size range clamping.
     // TODO(jmadill): Narrow driver range once fixed. http://anglebug.com/2970
-    if (IsNvidia(mPhysicalDeviceProperties.vendorID))
-    {
-        mFeatures.clampPointSize.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION((&mFeatures), clampPointSize, isNvidia)
 
-#if defined(ANGLE_PLATFORM_ANDROID)
     // Work around ineffective compute-graphics barriers on Nexus 5X.
     // TODO(syoussefi): Figure out which other vendors and driver versions are affected.
     // http://anglebug.com/3019
-    mFeatures.flushAfterVertexConversion.enabled =
-        IsNexus5X(mPhysicalDeviceProperties.vendorID, mPhysicalDeviceProperties.deviceID);
-#endif
+    ANGLE_FEATURE_CONDITION((&mFeatures), flushAfterVertexConversion,
+                            IsAndroid() && IsNexus5X(mPhysicalDeviceProperties.vendorID,
+                                                     mPhysicalDeviceProperties.deviceID))
 
-    if (ExtensionFound(VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, deviceExtensionNames))
-    {
-        mFeatures.supportsIncrementalPresent.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION(
+        (&mFeatures), supportsIncrementalPresent,
+        ExtensionFound(VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, deviceExtensionNames))
 
 #if defined(ANGLE_PLATFORM_ANDROID)
-    mFeatures.supportsAndroidHardwareBuffer.enabled =
-        ExtensionFound(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME,
-                       deviceExtensionNames) &&
-        ExtensionFound(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, deviceExtensionNames);
+    ANGLE_FEATURE_CONDITION(
+        (&mFeatures), supportsAndroidHardwareBuffer,
+        IsAndroid() &&
+            ExtensionFound(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME,
+                           deviceExtensionNames) &&
+            ExtensionFound(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, deviceExtensionNames))
 #endif
 
-    if (ExtensionFound(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, deviceExtensionNames))
-    {
-        mFeatures.supportsExternalMemoryFd.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION(
+        (&mFeatures), supportsExternalMemoryFd,
+        ExtensionFound(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, deviceExtensionNames))
 
-    if (ExtensionFound(VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, deviceExtensionNames))
-    {
-        mFeatures.supportsExternalSemaphoreFd.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION(
+        (&mFeatures), supportsExternalSemaphoreFd,
+        ExtensionFound(VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, deviceExtensionNames))
 
-    if (ExtensionFound(VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, deviceExtensionNames))
-    {
-        mFeatures.supportsShaderStencilExport.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION(
+        (&mFeatures), supportsShaderStencilExport,
+        ExtensionFound(VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, deviceExtensionNames))
 
     // TODO(syoussefi): when the code path using the extension is implemented, this should be
     // conditioned to the extension not being present as well.  http://anglebug.com/3206
-    if (mPhysicalDeviceFeatures.vertexPipelineStoresAndAtomics)
-    {
-        mFeatures.emulateTransformFeedback.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION((&mFeatures), emulateTransformFeedback,
+                            mPhysicalDeviceFeatures.vertexPipelineStoresAndAtomics)
 
-    if (IsLinux() && IsIntel(mPhysicalDeviceProperties.vendorID))
-    {
-        mFeatures.disableFifoPresentMode.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION((&mFeatures), disableFifoPresentMode, IsLinux() && isIntel)
 
-    if (IsAndroid() && IsQualcomm(mPhysicalDeviceProperties.vendorID))
-    {
-        if (vk::CommandBuffer::ExecutesInline())
-        {
-            mFeatures.restartRenderPassAfterLoadOpClear.enabled = true;
-        }
+    ANGLE_FEATURE_CONDITION((&mFeatures), restartRenderPassAfterLoadOpClear,
+                            IsAndroid() && isQualcomm && vk::CommandBuffer::ExecutesInline())
 
-        mFeatures.bindEmptyForUnusedDescriptorSets.enabled = true;
+    ANGLE_FEATURE_CONDITION((&mFeatures), bindEmptyForUnusedDescriptorSets,
+                            IsAndroid() && isQualcomm)
 
-        mFeatures.forceOldRewriteStructSamplers.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION((&mFeatures), forceOldRewriteStructSamplers, IsAndroid() && isQualcomm)
 
-    if (IsWindows() && IsIntel(mPhysicalDeviceProperties.vendorID))
-    {
-        mFeatures.forceNonZeroScissor.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION((&mFeatures), forceNonZeroScissor, IsWindows() && isIntel)
 
-    if (IsIntel(mPhysicalDeviceProperties.vendorID) ||
-        (IsWindows() && IsAMD(mPhysicalDeviceProperties.vendorID)))
-    {
-        mFeatures.perFrameWindowSizeQuery.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION((&mFeatures), perFrameWindowSizeQuery,
+                            isIntel || (IsWindows() && isAMD))
 
-    if (IsWindows() && IsAMD(mPhysicalDeviceProperties.vendorID))
-    {
-        // Disabled on AMD/windows due to buggy behavior.
-        mFeatures.disallowSeamfulCubeMapEmulation.enabled = true;
-    }
+    // Disabled on AMD/windows due to buggy behavior.
+    ANGLE_FEATURE_CONDITION((&mFeatures), disallowSeamfulCubeMapEmulation, IsWindows() && isAMD)
 
-    if (IsAndroid() && IsQualcomm(mPhysicalDeviceProperties.vendorID))
-    {
-        mFeatures.forceD16TexFilter.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION((&mFeatures), forceD16TexFilter, IsAndroid() && isQualcomm)
 
-    if (IsAndroid() && IsQualcomm(mPhysicalDeviceProperties.vendorID))
-    {
-        mFeatures.disableFlippingBlitWithCommand.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION((&mFeatures), disableFlippingBlitWithCommand, IsAndroid() && isQualcomm)
 
-    if (IsPixel2(mPhysicalDeviceProperties.vendorID, mPhysicalDeviceProperties.deviceID) ||
-        IsPixel1XL(mPhysicalDeviceProperties.vendorID, mPhysicalDeviceProperties.deviceID))
-    {
-        mFeatures.transientCommandBuffer.enabled = true;
-    }
+    ANGLE_FEATURE_CONDITION(
+        (&mFeatures), transientCommandBuffer,
+        IsPixel2(mPhysicalDeviceProperties.vendorID, mPhysicalDeviceProperties.deviceID) ||
+            IsPixel1XL(mPhysicalDeviceProperties.vendorID, mPhysicalDeviceProperties.deviceID))
+
+    angle::PlatformMethods *platform = ANGLEPlatformCurrent();
+    platform->overrideFeaturesVk(platform, &mFeatures);
 }
 
 void RendererVk::initPipelineCacheVkKey()

src/libANGLE/validationEGL.cpp

@@ -3941,6 +3941,7 @@ Error ValidateQueryStringiANGLE(const Display *display, EGLint name, EGLint inde
         case EGL_FEATURE_DESCRIPTION_ANGLE:
         case EGL_FEATURE_BUG_ANGLE:
         case EGL_FEATURE_STATUS_ANGLE:
+        case EGL_FEATURE_CONDITION_ANGLE:
             break;
         default:
             return EglBadParameter() << "name is not valid.";

src/tests/egl_tests/EGLFeatureControlTest.cpp

@@ -101,6 +101,8 @@ TEST_P(EGLFeatureControlTest, QueryAll)
         EXPECT_STREQ(features[i]->bug, eglQueryStringiANGLE(mDisplay, EGL_FEATURE_BUG_ANGLE, i));
         EXPECT_STREQ(FeatureStatusToString(features[i]->enabled),
                      eglQueryStringiANGLE(mDisplay, EGL_FEATURE_STATUS_ANGLE, i));
+        EXPECT_STREQ(features[i]->condition,
+                     eglQueryStringiANGLE(mDisplay, EGL_FEATURE_CONDITION_ANGLE, i));
         ASSERT_EGL_SUCCESS();
     }
 }