Dawn: Promote DisallowUnsafeAPIs as instance toggle

This CL add Instance and Adapter toggle stage, and promote
DisallowUnsafeAPIs as an instance toggle, and can be required using
DawnTogglesDescriptor chained in instance descriptor when creating
instance. The instance's toggles state will get inherited to adapters
and devices it create. Related tests are implemented and updated.

Toggles inheritance can be overriden if not forced, so requiring
DisallowUnsafeAPIs when creating device is still available and working
like before.

Note that currently we don't have toggle of adapter stage, and can not
require toggles when creating adapter, until follow up CLs implement it.
Currently the toggles state of a adapter is simply inherited from
instance.

Bug: dawn:1495
Change-Id: I6bf7aa0f950a99451afcc2cab5322c924b7d9520
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/122021
Commit-Queue: Zhaoming Jiang <zhaoming.jiang@intel.com>
Reviewed-by: Austin Eng <enga@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>

src/dawn/native/Adapter.cpp

@@ -27,10 +27,11 @@
 
 namespace dawn::native {
 
-AdapterBase::AdapterBase(InstanceBase* instance, wgpu::BackendType backend)
-    : mInstance(instance), mBackend(backend) {
-    mSupportedFeatures.EnableFeature(Feature::DawnNative);
-    mSupportedFeatures.EnableFeature(Feature::DawnInternalUsages);
+AdapterBase::AdapterBase(InstanceBase* instance,
+                         wgpu::BackendType backend,
+                         const TogglesState& adapterToggles)
+    : mInstance(instance), mBackend(backend), mTogglesState(adapterToggles) {
+    ASSERT(adapterToggles.GetStage() == ToggleStage::Adapter);
 }
 
 AdapterBase::~AdapterBase() = default;
@@ -39,6 +40,8 @@ MaybeError AdapterBase::Initialize() {
     DAWN_TRY_CONTEXT(InitializeImpl(), "initializing adapter (backend=%s)", mBackend);
     InitializeVendorArchitectureImpl();
 
+    mSupportedFeatures.EnableFeature(Feature::DawnNative);
+    mSupportedFeatures.EnableFeature(Feature::DawnInternalUsages);
     InitializeSupportedFeaturesImpl();
 
     DAWN_TRY_CONTEXT(
@@ -206,6 +209,10 @@ bool AdapterBase::GetLimits(SupportedLimits* limits) const {
     return true;
 }
 
+const TogglesState& AdapterBase::GetTogglesState() const {
+    return mTogglesState;
+}
+
 MaybeError AdapterBase::ValidateFeatureSupportedWithDeviceToggles(
     wgpu::FeatureName feature,
     const TogglesState& deviceTogglesState) {
@@ -229,8 +236,8 @@ ResultOrError<Ref<DeviceBase>> AdapterBase::CreateDeviceInternal(
     const DeviceDescriptor* descriptor) {
     ASSERT(descriptor != nullptr);
 
-    // Create device toggles state from required toggles descriptor.
-    // TODO(dawn:1495): After implementing adapter toggles, also inherite adapter toggles state.
+    // Create device toggles state from required toggles descriptor and inherited adapter toggles
+    // state.
     const DawnTogglesDescriptor* deviceTogglesDesc = nullptr;
     FindInChain(descriptor->nextInChain, &deviceTogglesDesc);
 
@@ -261,21 +268,21 @@ ResultOrError<Ref<DeviceBase>> AdapterBase::CreateDeviceInternal(
         deviceTogglesDesc = &convertedDeviceTogglesDesc;
     }
 
-    // Create device toggles state from user-given toggles descriptor, and set up forced and default
-    // toggles.
-    // TODO(dawn:1495): After implementing adapter toggles, device toggles state should also inherit
-    // from adapter toggles state.
+    // Create device toggles state.
     TogglesState deviceToggles =
         TogglesState::CreateFromTogglesDescriptor(deviceTogglesDesc, ToggleStage::Device);
+    deviceToggles.InheritFrom(mTogglesState);
     // Default toggles for all backend
     deviceToggles.Default(Toggle::LazyClearResourceOnFirstUse, true);
-    deviceToggles.Default(Toggle::DisallowUnsafeAPIs, true);
+
     // Backend-specific forced and default device toggles
     SetupBackendDeviceToggles(&deviceToggles);
 
     // Validate all required features are supported by the adapter and suitable under given toggles.
-    // TODO(dawn:1495): After implementing adapter toggles, validate supported features using
-    // adapter toggles instead of device toggles.
+    // Note that certain toggles in device toggles state may be overriden by user and different from
+    // the adapter toggles state.
+    // TODO(dawn:1495): After implementing adapter toggles, decide whether we should validate
+    // supported features using adapter toggles or device toggles.
     for (uint32_t i = 0; i < descriptor->requiredFeaturesCount; ++i) {
         wgpu::FeatureName feature = descriptor->requiredFeatures[i];
         DAWN_TRY(ValidateFeatureSupportedWithDeviceToggles(feature, deviceToggles));

src/dawn/native/Adapter.h

@@ -34,7 +34,9 @@ class DeviceBase;
 
 class AdapterBase : public RefCounted {
   public:
-    AdapterBase(InstanceBase* instance, wgpu::BackendType backend);
+    AdapterBase(InstanceBase* instance,
+                wgpu::BackendType backend,
+                const TogglesState& adapterToggles);
     ~AdapterBase() override;
 
     MaybeError Initialize();
@@ -65,6 +67,9 @@ class AdapterBase : public RefCounted {
 
     void SetUseTieredLimits(bool useTieredLimits);
 
+    // Get the actual toggles state of the adapter.
+    const TogglesState& GetTogglesState() const;
+
     virtual bool SupportsExternalImages() const = 0;
 
   protected:
@@ -113,6 +118,10 @@ class AdapterBase : public RefCounted {
     virtual MaybeError ResetInternalDeviceForTestingImpl();
     Ref<InstanceBase> mInstance;
     wgpu::BackendType mBackend;
+
+    // Adapter toggles state, currently only inherited from instance toggles state.
+    TogglesState mTogglesState;
+
     CombinedLimits mLimits;
     bool mUseTieredLimits = false;
 };

src/dawn/native/BackendConnection.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "dawn/native/BackendConnection.h"
+#include "dawn/native/Instance.h"
 
 namespace dawn::native {
 
@@ -28,7 +29,8 @@ InstanceBase* BackendConnection::GetInstance() const {
 }
 
 ResultOrError<std::vector<Ref<AdapterBase>>> BackendConnection::DiscoverAdapters(
-    const AdapterDiscoveryOptionsBase* options) {
+    const AdapterDiscoveryOptionsBase* options,
+    const TogglesState& adapterToggles) {
     return DAWN_VALIDATION_ERROR("DiscoverAdapters not implemented for this backend.");
 }
 

src/dawn/native/BackendConnection.h

@@ -20,6 +20,7 @@
 
 #include "dawn/native/Adapter.h"
 #include "dawn/native/DawnNative.h"
+#include "dawn/native/Toggles.h"
 
 namespace dawn::native {
 
@@ -35,11 +36,13 @@ class BackendConnection {
 
     // Returns all the adapters for the system that can be created by the backend, without extra
     // options (such as debug adapters, custom driver libraries, etc.)
-    virtual std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() = 0;
+    virtual std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+        const TogglesState& adapterToggles) = 0;
 
     // Returns new adapters created with the backend-specific options.
     virtual ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
-        const AdapterDiscoveryOptionsBase* options);
+        const AdapterDiscoveryOptionsBase* options,
+        const TogglesState& adapterToggles);
 
   private:
     InstanceBase* mInstance = nullptr;

src/dawn/native/Instance.cpp

@@ -23,6 +23,7 @@
 #include "dawn/native/ChainUtils_autogen.h"
 #include "dawn/native/ErrorData.h"
 #include "dawn/native/Surface.h"
+#include "dawn/native/Toggles.h"
 #include "dawn/native/ValidationUtils_autogen.h"
 #include "dawn/platform/DawnPlatform.h"
 
@@ -110,18 +111,30 @@ InstanceBase* APICreateInstance(const InstanceDescriptor* descriptor) {
 
 // static
 Ref<InstanceBase> InstanceBase::Create(const InstanceDescriptor* descriptor) {
-    Ref<InstanceBase> instance = AcquireRef(new InstanceBase);
     static constexpr InstanceDescriptor kDefaultDesc = {};
     if (descriptor == nullptr) {
         descriptor = &kDefaultDesc;
     }
+
+    const DawnTogglesDescriptor* instanceTogglesDesc = nullptr;
+    FindInChain(descriptor->nextInChain, &instanceTogglesDesc);
+
+    // Set up the instance toggle state from toggles descriptor
+    TogglesState instanceToggles =
+        TogglesState::CreateFromTogglesDescriptor(instanceTogglesDesc, ToggleStage::Instance);
+    // By default enable the DisallowUnsafeAPIs instance toggle, it will be inherited to adapters
+    // and devices created by this instance if not overriden.
+    // TODO(dawn:1685): Rename DisallowUnsafeAPIs to AllowUnsafeAPIs, and change relating logic.
+    instanceToggles.Default(Toggle::DisallowUnsafeAPIs, true);
+
+    Ref<InstanceBase> instance = AcquireRef(new InstanceBase(instanceToggles));
     if (instance->ConsumedError(instance->Initialize(descriptor))) {
         return nullptr;
     }
     return instance;
 }
 
-InstanceBase::InstanceBase() = default;
+InstanceBase::InstanceBase(const TogglesState& instanceToggles) : mToggles(instanceToggles) {}
 
 InstanceBase::~InstanceBase() = default;
 
@@ -138,7 +151,9 @@ void InstanceBase::WillDropLastExternalRef() {
 
 // TODO(crbug.com/dawn/832): make the platform an initialization parameter of the instance.
 MaybeError InstanceBase::Initialize(const InstanceDescriptor* descriptor) {
-    DAWN_TRY(ValidateSingleSType(descriptor->nextInChain, wgpu::SType::DawnInstanceDescriptor));
+    DAWN_TRY(ValidateSTypes(descriptor->nextInChain, {{wgpu::SType::DawnInstanceDescriptor},
+                                                      {wgpu::SType::DawnTogglesDescriptor}}));
+
     const DawnInstanceDescriptor* dawnDesc = nullptr;
     FindInChain(descriptor->nextInChain, &dawnDesc);
     if (dawnDesc != nullptr) {
@@ -280,7 +295,14 @@ void InstanceBase::DiscoverDefaultAdapters() {
 
     // Query and merge all default adapters for all backends
     for (std::unique_ptr<BackendConnection>& backend : mBackends) {
-        std::vector<Ref<AdapterBase>> backendAdapters = backend->DiscoverDefaultAdapters();
+        // Set up toggles state for default adapters, currently adapter don't have a toggles
+        // descriptor so just inherit from instance toggles.
+        // TODO(dawn:1495): Handle the adapter toggles descriptor after implemented.
+        TogglesState adapterToggles = TogglesState(ToggleStage::Adapter);
+        adapterToggles.InheritFrom(mToggles);
+
+        std::vector<Ref<AdapterBase>> backendAdapters =
+            backend->DiscoverDefaultAdapters(adapterToggles);
 
         for (Ref<AdapterBase>& adapter : backendAdapters) {
             ASSERT(adapter->GetBackendType() == backend->GetType());
@@ -306,6 +328,10 @@ bool InstanceBase::DiscoverAdapters(const AdapterDiscoveryOptionsBase* options)
     return true;
 }
 
+const TogglesState& InstanceBase::GetTogglesState() const {
+    return mToggles;
+}
+
 const ToggleInfo* InstanceBase::GetToggleInfo(const char* toggleName) {
     return mTogglesInfo.GetToggleInfo(toggleName);
 }
@@ -397,8 +423,14 @@ MaybeError InstanceBase::DiscoverAdaptersInternal(const AdapterDiscoveryOptionsB
         }
         foundBackend = true;
 
+        // Set up toggles state for default adapters, currently adapter don't have a toggles
+        // descriptor so just inherit from instance toggles.
+        // TODO(dawn:1495): Handle the adapter toggles descriptor after implemented.
+        TogglesState adapterToggles = TogglesState(ToggleStage::Adapter);
+        adapterToggles.InheritFrom(mToggles);
+
         std::vector<Ref<AdapterBase>> newAdapters;
-        DAWN_TRY_ASSIGN(newAdapters, backend->DiscoverAdapters(options));
+        DAWN_TRY_ASSIGN(newAdapters, backend->DiscoverAdapters(options, adapterToggles));
 
         for (Ref<AdapterBase>& adapter : newAdapters) {
             ASSERT(adapter->GetBackendType() == backend->GetType());

src/dawn/native/Instance.h

@@ -72,6 +72,8 @@ class InstanceBase final : public RefCountedWithExternalCount {
         return false;
     }
 
+    const TogglesState& GetTogglesState() const;
+
     // Used to query the details of a toggle. Return nullptr if toggleName is not a valid name
     // of a toggle supported in Dawn.
     const ToggleInfo* GetToggleInfo(const char* toggleName);
@@ -113,7 +115,7 @@ class InstanceBase final : public RefCountedWithExternalCount {
     Surface* APICreateSurface(const SurfaceDescriptor* descriptor);
 
   private:
-    InstanceBase();
+    explicit InstanceBase(const TogglesState& instanceToggles);
     ~InstanceBase() override;
 
     void WillDropLastExternalRef() override;
@@ -150,6 +152,8 @@ class InstanceBase final : public RefCountedWithExternalCount {
     std::vector<std::unique_ptr<BackendConnection>> mBackends;
     std::vector<Ref<AdapterBase>> mAdapters;
 
+    TogglesState mToggles;
+
     FeaturesInfo mFeaturesInfo;
     TogglesInfo mTogglesInfo;
 

src/dawn/native/Toggles.cpp

@@ -176,7 +176,7 @@ static constexpr ToggleEnumAndInfoList kToggleNameAndInfoList = {{
      {"disallow_unsafe_apis",
       "Produces validation errors on API entry points or parameter combinations that aren't "
       "considered secure yet.",
-      "http://crbug.com/1138528", ToggleStage::Device}},
+      "http://crbug.com/1138528", ToggleStage::Instance}},
     {Toggle::FlushBeforeClientWaitSync,
      {"flush_before_client_wait_sync",
       "Call glFlush before glClientWaitSync to work around bugs in the latter",
@@ -447,7 +447,9 @@ TogglesState TogglesState::CreateFromTogglesDescriptor(const DawnTogglesDescript
         Toggle toggle = togglesInfo.ToggleNameToEnum(togglesDesc->enabledToggles[i]);
         if (toggle != Toggle::InvalidEnum) {
             const ToggleInfo* toggleInfo = togglesInfo.GetToggleInfo(toggle);
-            if (toggleInfo->stage == requiredStage) {
+            // Accept the required toggles of current and earlier stage to allow override
+            // inheritance.
+            if (toggleInfo->stage <= requiredStage) {
                 togglesState.mTogglesSet.Set(toggle, true);
                 togglesState.mEnabledToggles.Set(toggle, true);
             }
@@ -457,7 +459,9 @@ TogglesState TogglesState::CreateFromTogglesDescriptor(const DawnTogglesDescript
         Toggle toggle = togglesInfo.ToggleNameToEnum(togglesDesc->disabledToggles[i]);
         if (toggle != Toggle::InvalidEnum) {
             const ToggleInfo* toggleInfo = togglesInfo.GetToggleInfo(toggle);
-            if (toggleInfo->stage == requiredStage) {
+            // Accept the required toggles of current and earlier stage to allow override
+            // inheritance.
+            if (toggleInfo->stage <= requiredStage) {
                 togglesState.mTogglesSet.Set(toggle, true);
                 togglesState.mEnabledToggles.Set(toggle, false);
             }
@@ -467,6 +471,30 @@ TogglesState TogglesState::CreateFromTogglesDescriptor(const DawnTogglesDescript
     return togglesState;
 }
 
+TogglesState& TogglesState::InheritFrom(const TogglesState& inheritedToggles) {
+    ASSERT(inheritedToggles.GetStage() < mStage);
+
+    // Do inheritance. All toggles that are force-set in the inherited toggles states would
+    // be force-set in the result toggles state, and all toggles that are set in the inherited
+    // toggles states and not required in current toggles state would be set in the result toggles
+    // state.
+    for (uint32_t i : inheritedToggles.mTogglesSet.Iterate()) {
+        const Toggle& toggle = static_cast<Toggle>(i);
+        ASSERT(TogglesInfo::GetToggleInfo(toggle)->stage < mStage);
+        bool isEnabled = inheritedToggles.mEnabledToggles.Has(toggle);
+        bool isForced = inheritedToggles.mForcedToggles.Has(toggle);
+        // Only inherit a toggle if it is not set by user requirement or is forced in earlier stage.
+        // In this way we allow user requirement override the inheritance if not forced.
+        if (!mTogglesSet.Has(toggle) || isForced) {
+            mTogglesSet.Set(toggle, true);
+            mEnabledToggles.Set(toggle, isEnabled);
+            mForcedToggles.Set(toggle, isForced);
+        }
+    }
+
+    return *this;
+}
+
 // Set a toggle to given state, if the toggle has not been already set. Do nothing otherwise.
 void TogglesState::Default(Toggle toggle, bool enabled) {
     ASSERT(toggle != Toggle::InvalidEnum);
@@ -492,6 +520,15 @@ void TogglesState::ForceSet(Toggle toggle, bool enabled) {
     mForcedToggles.Set(toggle, true);
 }
 
+TogglesState& TogglesState::SetForTesting(Toggle toggle, bool enabled, bool forced) {
+    ASSERT(toggle != Toggle::InvalidEnum);
+    mTogglesSet.Set(toggle, true);
+    mEnabledToggles.Set(toggle, enabled);
+    mForcedToggles.Set(toggle, forced);
+
+    return *this;
+}
+
 bool TogglesState::IsSet(Toggle toggle) const {
     // Ensure that the toggle never used earlier than its stage.
     ASSERT(TogglesInfo::GetToggleInfo(toggle)->stage <= mStage);

src/dawn/native/Toggles.h

@@ -127,17 +127,25 @@ class TogglesState {
     // Create an empty toggles state of given stage
     explicit TogglesState(ToggleStage stage);
 
-    // Create a RequiredTogglesSet from a DawnTogglesDescriptor, only considering toggles of
+    // Create a TogglesState from a DawnTogglesDescriptor, only considering toggles of
     // required toggle stage.
     static TogglesState CreateFromTogglesDescriptor(const DawnTogglesDescriptor* togglesDesc,
                                                     ToggleStage requiredStage);
 
+    // Inherit from a given toggles state of earlier stage, only inherit the forced and the
+    // unrequired toggles to allow overriding. Return *this to allow method chaining manner.
+    TogglesState& InheritFrom(const TogglesState& inheritedToggles);
+
     // Set a toggle of the same stage of toggles state stage if and only if it is not already set.
     void Default(Toggle toggle, bool enabled);
     // Force set a toggle of same stage of toggles state stage. A force-set toggle will get
     // inherited to all later stage as forced.
     void ForceSet(Toggle toggle, bool enabled);
 
+    // Set a toggle of any stage for testing propose. Return *this to allow method chaining
+    // manner.
+    TogglesState& SetForTesting(Toggle toggle, bool enabled, bool forced);
+
     // Return whether the toggle is set or not. Force-set is always treated as set.
     bool IsSet(Toggle toggle) const;
     // Return true if and only if the toggle is set to true.

src/dawn/native/d3d12/AdapterD3D12.cpp

@@ -28,8 +28,10 @@
 
 namespace dawn::native::d3d12 {
 
-Adapter::Adapter(Backend* backend, ComPtr<IDXGIAdapter3> hardwareAdapter)
-    : AdapterBase(backend->GetInstance(), wgpu::BackendType::D3D12),
+Adapter::Adapter(Backend* backend,
+                 ComPtr<IDXGIAdapter3> hardwareAdapter,
+                 const TogglesState& adapterToggles)
+    : AdapterBase(backend->GetInstance(), wgpu::BackendType::D3D12, adapterToggles),
       mHardwareAdapter(hardwareAdapter),
       mBackend(backend) {}
 

src/dawn/native/d3d12/AdapterD3D12.h

@@ -26,7 +26,9 @@ class Backend;
 
 class Adapter : public AdapterBase {
   public:
-    Adapter(Backend* backend, ComPtr<IDXGIAdapter3> hardwareAdapter);
+    Adapter(Backend* backend,
+            ComPtr<IDXGIAdapter3> hardwareAdapter,
+            const TogglesState& adapterToggles);
     ~Adapter() override;
 
     // AdapterBase Implementation

src/dawn/native/d3d12/BackendD3D12.cpp

@@ -69,10 +69,12 @@ ResultOrError<ComPtr<IDXGIFactory4>> CreateFactory(const PlatformFunctions* func
 }
 
 ResultOrError<Ref<AdapterBase>> CreateAdapterFromIDXGIAdapter(Backend* backend,
-                                                              ComPtr<IDXGIAdapter> dxgiAdapter) {
+                                                              ComPtr<IDXGIAdapter> dxgiAdapter,
+                                                              const TogglesState& adapterToggles) {
     ComPtr<IDXGIAdapter3> dxgiAdapter3;
     DAWN_TRY(CheckHRESULT(dxgiAdapter.As(&dxgiAdapter3), "DXGIAdapter retrieval"));
-    Ref<Adapter> adapter = AcquireRef(new Adapter(backend, std::move(dxgiAdapter3)));
+    Ref<Adapter> adapter =
+        AcquireRef(new Adapter(backend, std::move(dxgiAdapter3), adapterToggles));
     DAWN_TRY(adapter->Initialize());
 
     return {std::move(adapter)};
@@ -271,9 +273,9 @@ const PlatformFunctions* Backend::GetFunctions() const {
     return mFunctions.get();
 }
 
-std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
+std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters(const TogglesState& adapterToggles) {
     AdapterDiscoveryOptions options;
-    auto result = DiscoverAdapters(&options);
+    auto result = DiscoverAdapters(&options, adapterToggles);
     if (result.IsError()) {
         GetInstance()->ConsumedError(result.AcquireError());
         return {};
@@ -282,7 +284,8 @@ std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
 }
 
 ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
-    const AdapterDiscoveryOptionsBase* optionsBase) {
+    const AdapterDiscoveryOptionsBase* optionsBase,
+    const TogglesState& adapterToggles) {
     ASSERT(optionsBase->backendType == WGPUBackendType_D3D12);
     const AdapterDiscoveryOptions* options =
         static_cast<const AdapterDiscoveryOptions*>(optionsBase);
@@ -291,7 +294,8 @@ ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
     if (options->dxgiAdapter != nullptr) {
         // |dxgiAdapter| was provided. Discover just that adapter.
         Ref<AdapterBase> adapter;
-        DAWN_TRY_ASSIGN(adapter, CreateAdapterFromIDXGIAdapter(this, options->dxgiAdapter));
+        DAWN_TRY_ASSIGN(adapter,
+                        CreateAdapterFromIDXGIAdapter(this, options->dxgiAdapter, adapterToggles));
         adapters.push_back(std::move(adapter));
         return std::move(adapters);
     }
@@ -304,7 +308,8 @@ ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
         }
 
         ASSERT(dxgiAdapter != nullptr);
-        ResultOrError<Ref<AdapterBase>> adapter = CreateAdapterFromIDXGIAdapter(this, dxgiAdapter);
+        ResultOrError<Ref<AdapterBase>> adapter =
+            CreateAdapterFromIDXGIAdapter(this, dxgiAdapter, adapterToggles);
         if (adapter.IsError()) {
             GetInstance()->ConsumedError(adapter.AcquireError());
             continue;

src/dawn/native/d3d12/BackendD3D12.h

@@ -75,9 +75,11 @@ class Backend : public BackendConnection {
 
     const PlatformFunctions* GetFunctions() const;
 
-    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override;
+    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+        const TogglesState& adapterToggles) override;
     ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
-        const AdapterDiscoveryOptionsBase* optionsBase) override;
+        const AdapterDiscoveryOptionsBase* optionsBase,
+        const TogglesState& adapterToggles) override;
 
   private:
     // Acquiring DXC version information and store the result in mDxcVersionInfo. This function

src/dawn/native/metal/BackendMTL.h

@@ -26,9 +26,11 @@ class Backend : public BackendConnection {
     explicit Backend(InstanceBase* instance);
     ~Backend() override;
 
-    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override;
+    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+        const TogglesState& adapterToggles) override;
     ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
-        const AdapterDiscoveryOptionsBase* optionsBase) override;
+        const AdapterDiscoveryOptionsBase* optionsBase,
+        const TogglesState& adapterToggles) override;
 };
 
 }  // namespace dawn::native::metal

src/dawn/native/metal/BackendMTL.mm

@@ -255,8 +255,8 @@ DAWN_NOINLINE bool IsGPUCounterSupported(id<MTLDevice> device,
 
 class Adapter : public AdapterBase {
   public:
-    Adapter(InstanceBase* instance, id<MTLDevice> device)
-        : AdapterBase(instance, wgpu::BackendType::Metal), mDevice(device) {
+    Adapter(InstanceBase* instance, id<MTLDevice> device, const TogglesState& requiredAdapterToggle)
+        : AdapterBase(instance, wgpu::BackendType::Metal, requiredAdapterToggle), mDevice(device) {
         mName = std::string([[*mDevice name] UTF8String]);
 
         PCIIDs ids;
@@ -774,9 +774,9 @@ Backend::Backend(InstanceBase* instance) : BackendConnection(instance, wgpu::Bac
 
 Backend::~Backend() = default;
 
-std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
+std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters(const TogglesState& adapterToggles) {
     AdapterDiscoveryOptions options;
-    auto result = DiscoverAdapters(&options);
+    auto result = DiscoverAdapters(&options, adapterToggles);
     if (result.IsError()) {
         GetInstance()->ConsumedError(result.AcquireError());
         return {};
@@ -785,7 +785,8 @@ std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
 }
 
 ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
-    const AdapterDiscoveryOptionsBase* optionsBase) {
+    const AdapterDiscoveryOptionsBase* optionsBase,
+    const TogglesState& adapterToggles) {
     ASSERT(optionsBase->backendType == WGPUBackendType_Metal);
 
     std::vector<Ref<AdapterBase>> adapters;
@@ -793,7 +794,7 @@ ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
     NSRef<NSArray<id<MTLDevice>>> devices = AcquireNSRef(MTLCopyAllDevices());
 
     for (id<MTLDevice> device in devices.Get()) {
-        Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance(), device));
+        Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance(), device, adapterToggles));
         if (!GetInstance()->ConsumedError(adapter->Initialize())) {
             adapters.push_back(std::move(adapter));
         }
@@ -802,7 +803,8 @@ ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
 
     // iOS only has a single device so MTLCopyAllDevices doesn't exist there.
 #if defined(DAWN_PLATFORM_IOS)
-    Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance(), MTLCreateSystemDefaultDevice()));
+    Ref<Adapter> adapter =
+        AcquireRef(new Adapter(GetInstance(), MTLCreateSystemDefaultDevice(), adapterToggles));
     if (!GetInstance()->ConsumedError(adapter->Initialize())) {
         adapters.push_back(std::move(adapter));
     }

src/dawn/native/null/DeviceNull.cpp

@@ -30,7 +30,12 @@ namespace dawn::native::null {
 
 // Implementation of pre-Device objects: the null adapter, null backend connection and Connect()
 
-Adapter::Adapter(InstanceBase* instance) : AdapterBase(instance, wgpu::BackendType::Null) {
+Adapter::Adapter(InstanceBase* instance)
+    : Adapter(instance,
+              TogglesState(ToggleStage::Adapter).InheritFrom(instance->GetTogglesState())) {}
+
+Adapter::Adapter(InstanceBase* instance, const TogglesState& adapterToggles)
+    : AdapterBase(instance, wgpu::BackendType::Null, adapterToggles) {
     mVendorId = 0;
     mDeviceId = 0;
     mName = "Null backend";
@@ -85,11 +90,12 @@ class Backend : public BackendConnection {
     explicit Backend(InstanceBase* instance)
         : BackendConnection(instance, wgpu::BackendType::Null) {}
 
-    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override {
+    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+        const TogglesState& adapterToggles) override {
         // There is always a single Null adapter because it is purely CPU based and doesn't
         // depend on the system.
         std::vector<Ref<AdapterBase>> adapters;
-        Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance()));
+        Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance(), adapterToggles));
         adapters.push_back(std::move(adapter));
         return adapters;
     }

src/dawn/native/null/DeviceNull.h

@@ -171,7 +171,10 @@ class Device final : public DeviceBase {
 
 class Adapter : public AdapterBase {
   public:
+    // Create null adapter without providing toggles state for testing, only inherit instance's
+    // toggles state
     explicit Adapter(InstanceBase* instance);
+    Adapter(InstanceBase* instance, const TogglesState& adapterToggles);
     ~Adapter() override;
 
     // AdapterBase Implementation

src/dawn/native/opengl/AdapterGL.cpp

@@ -53,8 +53,10 @@ uint32_t GetVendorIdFromVendors(const char* vendor) {
 
 }  // anonymous namespace
 
-Adapter::Adapter(InstanceBase* instance, wgpu::BackendType backendType)
-    : AdapterBase(instance, backendType) {}
+Adapter::Adapter(InstanceBase* instance,
+                 wgpu::BackendType backendType,
+                 const TogglesState& adapterToggle)
+    : AdapterBase(instance, backendType, adapterToggle) {}
 
 MaybeError Adapter::InitializeGLFunctions(void* (*getProc)(const char*)) {
     // Use getProc to populate the dispatch table

src/dawn/native/opengl/AdapterGL.h

@@ -23,7 +23,9 @@ namespace dawn::native::opengl {
 
 class Adapter : public AdapterBase {
   public:
-    Adapter(InstanceBase* instance, wgpu::BackendType backendType);
+    Adapter(InstanceBase* instance,
+            wgpu::BackendType backendType,
+            const TogglesState& adapterToggle);
 
     MaybeError InitializeGLFunctions(void* (*getProc)(const char*));
 

src/dawn/native/opengl/BackendGL.cpp

@@ -33,7 +33,7 @@ namespace dawn::native::opengl {
 Backend::Backend(InstanceBase* instance, wgpu::BackendType backendType)
     : BackendConnection(instance, backendType) {}
 
-std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
+std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters(const TogglesState& adapterToggles) {
     std::vector<Ref<AdapterBase>> adapters;
 #if DAWN_PLATFORM_IS(WINDOWS)
     const char* eglLib = "libEGL.dll";
@@ -69,7 +69,7 @@ std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
 
     context->MakeCurrent();
 
-    auto result = DiscoverAdapters(&options);
+    auto result = DiscoverAdapters(&options, adapterToggles);
 
     if (result.IsError()) {
         GetInstance()->ConsumedError(result.AcquireError());
@@ -84,7 +84,8 @@ std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
 }
 
 ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
-    const AdapterDiscoveryOptionsBase* optionsBase) {
+    const AdapterDiscoveryOptionsBase* optionsBase,
+    const TogglesState& adapterToggles) {
     // TODO(cwallez@chromium.org): For now only create a single OpenGL adapter because don't
     // know how to handle MakeCurrent.
     DAWN_INVALID_IF(mCreatedAdapter, "The OpenGL backend can only create a single adapter.");
@@ -95,8 +96,8 @@ ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
 
     DAWN_INVALID_IF(options->getProc == nullptr, "AdapterDiscoveryOptions::getProc must be set");
 
-    Ref<Adapter> adapter = AcquireRef(
-        new Adapter(GetInstance(), static_cast<wgpu::BackendType>(optionsBase->backendType)));
+    Ref<Adapter> adapter = AcquireRef(new Adapter(
+        GetInstance(), static_cast<wgpu::BackendType>(optionsBase->backendType), adapterToggles));
     DAWN_TRY(adapter->InitializeGLFunctions(options->getProc));
     DAWN_TRY(adapter->Initialize());
 

src/dawn/native/opengl/BackendGL.h

@@ -26,9 +26,11 @@ class Backend : public BackendConnection {
   public:
     Backend(InstanceBase* instance, wgpu::BackendType backendType);
 
-    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override;
+    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+        const TogglesState& adapterToggles) override;
     ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
-        const AdapterDiscoveryOptionsBase* options) override;
+        const AdapterDiscoveryOptionsBase* option,
+        const TogglesState& adapterToggless) override;
 
   private:
     bool mCreatedAdapter = false;

src/dawn/native/vulkan/AdapterVk.cpp

@@ -58,8 +58,9 @@ gpu_info::DriverVersion DecodeVulkanDriverVersion(uint32_t vendorID, uint32_t ve
 
 Adapter::Adapter(InstanceBase* instance,
                  VulkanInstance* vulkanInstance,
-                 VkPhysicalDevice physicalDevice)
-    : AdapterBase(instance, wgpu::BackendType::Vulkan),
+                 VkPhysicalDevice physicalDevice,
+                 const TogglesState& adapterToggles)
+    : AdapterBase(instance, wgpu::BackendType::Vulkan, adapterToggles),
       mPhysicalDevice(physicalDevice),
       mVulkanInstance(vulkanInstance) {}
 

src/dawn/native/vulkan/AdapterVk.h

@@ -29,7 +29,8 @@ class Adapter : public AdapterBase {
   public:
     Adapter(InstanceBase* instance,
             VulkanInstance* vulkanInstance,
-            VkPhysicalDevice physicalDevice);
+            VkPhysicalDevice physicalDevice,
+            const TogglesState& adapterToggles);
     ~Adapter() override;
 
     // AdapterBase Implementation

src/dawn/native/vulkan/BackendVk.cpp

@@ -457,9 +457,9 @@ Backend::Backend(InstanceBase* instance) : BackendConnection(instance, wgpu::Bac
 
 Backend::~Backend() = default;
 
-std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
+std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters(const TogglesState& adapterToggles) {
     AdapterDiscoveryOptions options;
-    auto result = DiscoverAdapters(&options);
+    auto result = DiscoverAdapters(&options, adapterToggles);
     if (result.IsError()) {
         GetInstance()->ConsumedError(result.AcquireError());
         return {};
@@ -468,7 +468,8 @@ std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
 }
 
 ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
-    const AdapterDiscoveryOptionsBase* optionsBase) {
+    const AdapterDiscoveryOptionsBase* optionsBase,
+    const TogglesState& adapterToggles) {
     ASSERT(optionsBase->backendType == WGPUBackendType_Vulkan);
 
     const AdapterDiscoveryOptions* options =
@@ -497,8 +498,8 @@ ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
         const std::vector<VkPhysicalDevice>& physicalDevices =
             mVulkanInstances[icd]->GetPhysicalDevices();
         for (uint32_t i = 0; i < physicalDevices.size(); ++i) {
-            Ref<Adapter> adapter =
-                AcquireRef(new Adapter(instance, mVulkanInstances[icd].Get(), physicalDevices[i]));
+            Ref<Adapter> adapter = AcquireRef(new Adapter(instance, mVulkanInstances[icd].Get(),
+                                                          physicalDevices[i], adapterToggles));
             if (instance->ConsumedError(adapter->Initialize())) {
                 continue;
             }

src/dawn/native/vulkan/BackendVk.h

@@ -91,9 +91,11 @@ class Backend : public BackendConnection {
 
     MaybeError Initialize();
 
-    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override;
+    std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+        const TogglesState& adapterToggles) override;
     ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
-        const AdapterDiscoveryOptionsBase* optionsBase) override;
+        const AdapterDiscoveryOptionsBase* optionsBase,
+        const TogglesState& adapterToggles) override;
 
   private:
     ityp::array<ICD, Ref<VulkanInstance>, 2> mVulkanInstances = {};