src/dawn/wire/client/Instance.cpp - dawn - Git at Google

 // Copyright 2021 The Dawn & Tint Authors
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 //
 // 1. Redistributions of source code must retain the above copyright notice, this
 //    list of conditions and the following disclaimer.
 //
 // 2. Redistributions in binary form must reproduce the above copyright notice,
 //    this list of conditions and the following disclaimer in the documentation
 //    and/or other materials provided with the distribution.
 //
 // 3. Neither the name of the copyright holder nor the names of its
 //    contributors may be used to endorse or promote products derived from
 //    this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "dawn/wire/client/Instance.h"

 #include <memory>
 #include <string>
 #include <utility>

 #include "dawn/common/Log.h"
 #include "dawn/common/WGSLFeatureMapping.h"
 #include "dawn/wire/client/ApiObjects_autogen.h"
 #include "dawn/wire/client/Client.h"
 #include "dawn/wire/client/EventManager.h"
 #include "dawn/wire/client/webgpu.h"
 #include "partition_alloc/pointers/raw_ptr.h"
 #include "tint/lang/wgsl/features/language_feature.h"
 #include "tint/lang/wgsl/features/status.h"

 namespace dawn::wire::client {
 namespace {

 class RequestAdapterEvent : public TrackedEvent {
   public:
     static constexpr EventType kType = EventType::RequestAdapter;

     RequestAdapterEvent(const WGPURequestAdapterCallbackInfo& callbackInfo, Adapter* adapter)
         : TrackedEvent(callbackInfo.mode),
           mCallback(callbackInfo.callback),
           mUserdata1(callbackInfo.userdata),
           mAdapter(adapter) {}

     RequestAdapterEvent(const WGPURequestAdapterCallbackInfo2& callbackInfo, Adapter* adapter)
         : TrackedEvent(callbackInfo.mode),
           mCallback2(callbackInfo.callback),
           mUserdata1(callbackInfo.userdata1),
           mUserdata2(callbackInfo.userdata2),
           mAdapter(adapter) {}

     EventType GetType() override { return kType; }

     WireResult ReadyHook(FutureID futureID,
                          WGPURequestAdapterStatus status,
                          const char* message,
                          const WGPUAdapterProperties* properties,
                          const WGPUSupportedLimits* limits,
                          uint32_t featuresCount,
                          const WGPUFeatureName* features) {
         DAWN_ASSERT(mAdapter != nullptr);
         mStatus = status;
         if (message != nullptr) {
             mMessage = message;
         }
         if (status == WGPURequestAdapterStatus_Success) {
             mAdapter->SetProperties(properties);
             mAdapter->SetLimits(limits);
             mAdapter->SetFeatures(features, featuresCount);
         }
         return WireResult::Success;
     }

   private:
     void CompleteImpl(FutureID futureID, EventCompletionType completionType) override {
         if (mCallback == nullptr && mCallback2 == nullptr) {
             // If there's no callback, just clean up the resources.
             mAdapter.ExtractAsDangling()->Release();
             mUserdata1.ExtractAsDangling();
             mUserdata2.ExtractAsDangling();
             return;
         }

         if (completionType == EventCompletionType::Shutdown) {
             mStatus = WGPURequestAdapterStatus_InstanceDropped;
             mMessage = "A valid external Instance reference no longer exists.";
         }

         Adapter* adapter = mAdapter.ExtractAsDangling();
         if (mCallback) {
             mCallback(mStatus,
                       ToAPI(mStatus == WGPURequestAdapterStatus_Success ? adapter : nullptr),
                       mMessage ? mMessage->c_str() : nullptr, mUserdata1.ExtractAsDangling());
         } else {
             mCallback2(mStatus,
                        ToAPI(mStatus == WGPURequestAdapterStatus_Success ? adapter : nullptr),
                        mMessage ? mMessage->c_str() : nullptr, mUserdata1.ExtractAsDangling(),
                        mUserdata2.ExtractAsDangling());
         }
     }

     WGPURequestAdapterCallback mCallback = nullptr;
     WGPURequestAdapterCallback2 mCallback2 = nullptr;
     raw_ptr<void> mUserdata1;
     raw_ptr<void> mUserdata2;

     // Note that the message is optional because we want to return nullptr when it wasn't set
     // instead of a pointer to an empty string.
     WGPURequestAdapterStatus mStatus;
     std::optional<std::string> mMessage;

     // The adapter is created when we call RequestAdapter(F). It is guaranteed to be alive
     // throughout the duration of a RequestAdapterEvent because the Event essentially takes
     // ownership of it until either an error occurs at which point the Event cleans it up, or it
     // returns the adapter to the user who then takes ownership as the Event goes away.
     raw_ptr<Adapter> mAdapter = nullptr;
 };

 WGPUWGSLFeatureName ToWGPUFeature(tint::wgsl::LanguageFeature f) {
     switch (f) {
 #define CASE(WgslName, WgpuName)                \
     case tint::wgsl::LanguageFeature::WgslName: \
         return WGPUWGSLFeatureName_##WgpuName;
         DAWN_FOREACH_WGSL_FEATURE(CASE)
 #undef CASE
     }
 }

 }  // anonymous namespace

 // Instance

 Instance::Instance(const ObjectBaseParams& params) : ObjectWithEventsBase(params, params.handle) {}

 Instance::~Instance() {
     GetEventManager().TransitionTo(EventManager::State::InstanceDropped);
 }

 ObjectType Instance::GetObjectType() const {
     return ObjectType::Instance;
 }

 WireResult Instance::Initialize(const WGPUInstanceDescriptor* descriptor) {
     if (descriptor == nullptr) {
         return WireResult::Success;
     }

     if (descriptor->features.timedWaitAnyEnable) {
         dawn::ErrorLog() << "Wire client instance doesn't support timedWaitAnyEnable = true";
         return WireResult::FatalError;
     }
     if (descriptor->features.timedWaitAnyMaxCount > 0) {
         dawn::ErrorLog() << "Wire client instance doesn't support non-zero timedWaitAnyMaxCount";
         return WireResult::FatalError;
     }

     const WGPUDawnWireWGSLControl* wgslControl = nullptr;
     const WGPUDawnWGSLBlocklist* wgslBlocklist = nullptr;
     for (const WGPUChainedStruct* chain = descriptor->nextInChain; chain != nullptr;
          chain = chain->next) {
         switch (chain->sType) {
             case WGPUSType_DawnWireWGSLControl:
                 wgslControl = reinterpret_cast<const WGPUDawnWireWGSLControl*>(chain);
                 break;
             case WGPUSType_DawnWGSLBlocklist:
                 wgslBlocklist = reinterpret_cast<const WGPUDawnWGSLBlocklist*>(chain);
                 break;
             default:
                 dawn::ErrorLog() << "Wire client instance doesn't support InstanceDescriptor "
                                     "extension structure with sType ("
                                  << chain->sType << ")";
                 return WireResult::FatalError;
         }
     }

     GatherWGSLFeatures(wgslControl, wgslBlocklist);

     return WireResult::Success;
 }

 void Instance::RequestAdapter(const WGPURequestAdapterOptions* options,
                               WGPURequestAdapterCallback callback,
                               void* userdata) {
     WGPURequestAdapterCallbackInfo callbackInfo = {};
     callbackInfo.mode = WGPUCallbackMode_AllowSpontaneous;
     callbackInfo.callback = callback;
     callbackInfo.userdata = userdata;
     RequestAdapterF(options, callbackInfo);
 }

 WGPUFuture Instance::RequestAdapterF(const WGPURequestAdapterOptions* options,
                                      const WGPURequestAdapterCallbackInfo& callbackInfo) {
     Client* client = GetClient();
     Adapter* adapter = client->Make<Adapter>(GetEventManagerHandle());
     auto [futureIDInternal, tracked] =
         GetEventManager().TrackEvent(std::make_unique<RequestAdapterEvent>(callbackInfo, adapter));
     if (!tracked) {
         return {futureIDInternal};
     }

     InstanceRequestAdapterCmd cmd;
     cmd.instanceId = GetWireId();
     cmd.eventManagerHandle = GetEventManagerHandle();
     cmd.future = {futureIDInternal};
     cmd.adapterObjectHandle = adapter->GetWireHandle();
     cmd.options = options;
     cmd.userdataCount = 1;

     client->SerializeCommand(cmd);
     return {futureIDInternal};
 }

 WGPUFuture Instance::RequestAdapter2(const WGPURequestAdapterOptions* options,
                                      const WGPURequestAdapterCallbackInfo2& callbackInfo) {
     Client* client = GetClient();
     Adapter* adapter = client->Make<Adapter>(GetEventManagerHandle());
     auto [futureIDInternal, tracked] =
         GetEventManager().TrackEvent(std::make_unique<RequestAdapterEvent>(callbackInfo, adapter));
     if (!tracked) {
         return {futureIDInternal};
     }

     InstanceRequestAdapterCmd cmd;
     cmd.instanceId = GetWireId();
     cmd.eventManagerHandle = GetEventManagerHandle();
     cmd.future = {futureIDInternal};
     cmd.adapterObjectHandle = adapter->GetWireHandle();
     cmd.options = options;
     cmd.userdataCount = 2;

     client->SerializeCommand(cmd);
     return {futureIDInternal};
 }

 WireResult Client::DoInstanceRequestAdapterCallback(ObjectHandle eventManager,
                                                     WGPUFuture future,
                                                     WGPURequestAdapterStatus status,
                                                     const char* message,
                                                     const WGPUAdapterProperties* properties,
                                                     const WGPUSupportedLimits* limits,
                                                     uint32_t featuresCount,
                                                     const WGPUFeatureName* features) {
     return GetEventManager(eventManager)
         .SetFutureReady<RequestAdapterEvent>(future.id, status, message, properties, limits,
                                              featuresCount, features);
 }

 void Instance::ProcessEvents() {
     GetEventManager().ProcessPollEvents();

     // TODO(crbug.com/dawn/1987): The responsibility of ProcessEvents here is a bit mixed. It both
     // processes events coming in from the server, and also prompts the server to check for and
     // forward over new events - which won't be received until *after* this client-side
     // ProcessEvents completes.
     //
     // Fixing this nicely probably requires the server to more self-sufficiently
     // forward the events, which is half of making the wire fully invisible to use (which we might
     // like to do, someday, but not soon). This is easy for immediate events (like requestDevice)
     // and thread-driven events (async pipeline creation), but harder for queue fences where we have
     // to wait on the backend and then trigger Dawn code to forward the event.
     //
     // In the meantime, we could maybe do this on client->server flush to keep this concern in the
     // wire instead of in the API itself, but otherwise it's not significantly better so we just
     // keep it here for now for backward compatibility.
     InstanceProcessEventsCmd cmd;
     cmd.self = ToAPI(this);
     GetClient()->SerializeCommand(cmd);
 }

 WGPUWaitStatus Instance::WaitAny(size_t count, WGPUFutureWaitInfo* infos, uint64_t timeoutNS) {
     return GetEventManager().WaitAny(count, infos, timeoutNS);
 }

 void Instance::GatherWGSLFeatures(const WGPUDawnWireWGSLControl* wgslControl,
                                   const WGPUDawnWGSLBlocklist* wgslBlocklist) {
     WGPUDawnWireWGSLControl defaultWgslControl{};
     if (wgslControl == nullptr) {
         wgslControl = &defaultWgslControl;
     }

     for (auto wgslFeature : tint::wgsl::kAllLanguageFeatures) {
         // Skip over testing features if we don't have the toggle to expose them.
         if (!wgslControl->enableTesting) {
             switch (wgslFeature) {
                 case tint::wgsl::LanguageFeature::kChromiumTestingUnimplemented:
                 case tint::wgsl::LanguageFeature::kChromiumTestingUnsafeExperimental:
                 case tint::wgsl::LanguageFeature::kChromiumTestingExperimental:
                 case tint::wgsl::LanguageFeature::kChromiumTestingShippedWithKillswitch:
                 case tint::wgsl::LanguageFeature::kChromiumTestingShipped:
                     continue;
                 default:
                     break;
             }
         }

         // Expose the feature depending on its status and wgslControl.
         bool enable = false;
         switch (tint::wgsl::GetLanguageFeatureStatus(wgslFeature)) {
             case tint::wgsl::FeatureStatus::kUnknown:
             case tint::wgsl::FeatureStatus::kUnimplemented:
                 enable = false;
                 break;

             case tint::wgsl::FeatureStatus::kUnsafeExperimental:
                 enable = wgslControl->enableUnsafe;
                 break;
             case tint::wgsl::FeatureStatus::kExperimental:
                 enable = wgslControl->enableExperimental;
                 break;

             case tint::wgsl::FeatureStatus::kShippedWithKillswitch:
             case tint::wgsl::FeatureStatus::kShipped:
                 enable = true;
                 break;
         }

         if (enable) {
             mWGSLFeatures.emplace(ToWGPUFeature(wgslFeature));
         }
     }

     // Remove blocklisted features.
     if (wgslBlocklist != nullptr) {
         for (size_t i = 0; i < wgslBlocklist->blocklistedFeatureCount; i++) {
             const char* name = wgslBlocklist->blocklistedFeatures[i];
             tint::wgsl::LanguageFeature tintFeature = tint::wgsl::ParseLanguageFeature(name);
             WGPUWGSLFeatureName feature = ToWGPUFeature(tintFeature);

             // Ignore unknown features in the blocklist.
             if (feature == WGPUWGSLFeatureName_Undefined) {
                 continue;
             }

             mWGSLFeatures.erase(feature);
         }
     }
 }

 bool Instance::HasWGSLLanguageFeature(WGPUWGSLFeatureName feature) const {
     return mWGSLFeatures.contains(feature);
 }

 size_t Instance::EnumerateWGSLLanguageFeatures(WGPUWGSLFeatureName* features) const {
     if (features != nullptr) {
         for (WGPUWGSLFeatureName f : mWGSLFeatures) {
             *features = f;
             ++features;
         }
     }
     return mWGSLFeatures.size();
 }

 }  // namespace dawn::wire::client

 // Free-standing API functions

 DAWN_WIRE_EXPORT WGPUStatus wgpuDawnWireClientGetInstanceFeatures(WGPUInstanceFeatures* features) {
     if (features->nextInChain != nullptr) {
         return WGPUStatus_Error;
     }

     features->timedWaitAnyEnable = false;
     features->timedWaitAnyMaxCount = dawn::kTimedWaitAnyMaxCountDefault;
     return WGPUStatus_Success;
 }

 DAWN_WIRE_EXPORT WGPUInstance
 wgpuDawnWireClientCreateInstance(WGPUInstanceDescriptor const* descriptor) {
     DAWN_UNREACHABLE();
     return nullptr;
 }
	// Copyright 2021 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#include "dawn/wire/client/Instance.h"

	#include <memory>
	#include <string>
	#include <utility>

	#include "dawn/common/Log.h"
	#include "dawn/common/WGSLFeatureMapping.h"
	#include "dawn/wire/client/ApiObjects_autogen.h"
	#include "dawn/wire/client/Client.h"
	#include "dawn/wire/client/EventManager.h"
	#include "dawn/wire/client/webgpu.h"
	#include "partition_alloc/pointers/raw_ptr.h"
	#include "tint/lang/wgsl/features/language_feature.h"
	#include "tint/lang/wgsl/features/status.h"

	namespace dawn::wire::client {
	namespace {

	class RequestAdapterEvent : public TrackedEvent {
	public:
	static constexpr EventType kType = EventType::RequestAdapter;

	RequestAdapterEvent(const WGPURequestAdapterCallbackInfo& callbackInfo, Adapter* adapter)
	: TrackedEvent(callbackInfo.mode),
	mCallback(callbackInfo.callback),
	mUserdata1(callbackInfo.userdata),
	mAdapter(adapter) {}

	RequestAdapterEvent(const WGPURequestAdapterCallbackInfo2& callbackInfo, Adapter* adapter)
	: TrackedEvent(callbackInfo.mode),
	mCallback2(callbackInfo.callback),
	mUserdata1(callbackInfo.userdata1),
	mUserdata2(callbackInfo.userdata2),
	mAdapter(adapter) {}

	EventType GetType() override { return kType; }

	WireResult ReadyHook(FutureID futureID,
	WGPURequestAdapterStatus status,
	const char* message,
	const WGPUAdapterProperties* properties,
	const WGPUSupportedLimits* limits,
	uint32_t featuresCount,
	const WGPUFeatureName* features) {
	DAWN_ASSERT(mAdapter != nullptr);
	mStatus = status;
	if (message != nullptr) {
	mMessage = message;
	}
	if (status == WGPURequestAdapterStatus_Success) {
	mAdapter->SetProperties(properties);
	mAdapter->SetLimits(limits);
	mAdapter->SetFeatures(features, featuresCount);
	}
	return WireResult::Success;
	}

	private:
	void CompleteImpl(FutureID futureID, EventCompletionType completionType) override {
	if (mCallback == nullptr && mCallback2 == nullptr) {
	// If there's no callback, just clean up the resources.
	mAdapter.ExtractAsDangling()->Release();
	mUserdata1.ExtractAsDangling();
	mUserdata2.ExtractAsDangling();
	return;
	}

	if (completionType == EventCompletionType::Shutdown) {
	mStatus = WGPURequestAdapterStatus_InstanceDropped;
	mMessage = "A valid external Instance reference no longer exists.";
	}

	Adapter* adapter = mAdapter.ExtractAsDangling();
	if (mCallback) {
	mCallback(mStatus,
	ToAPI(mStatus == WGPURequestAdapterStatus_Success ? adapter : nullptr),
	mMessage ? mMessage->c_str() : nullptr, mUserdata1.ExtractAsDangling());
	} else {
	mCallback2(mStatus,
	ToAPI(mStatus == WGPURequestAdapterStatus_Success ? adapter : nullptr),
	mMessage ? mMessage->c_str() : nullptr, mUserdata1.ExtractAsDangling(),
	mUserdata2.ExtractAsDangling());
	}
	}

	WGPURequestAdapterCallback mCallback = nullptr;
	WGPURequestAdapterCallback2 mCallback2 = nullptr;
	raw_ptr<void> mUserdata1;
	raw_ptr<void> mUserdata2;

	// Note that the message is optional because we want to return nullptr when it wasn't set
	// instead of a pointer to an empty string.
	WGPURequestAdapterStatus mStatus;
	std::optional<std::string> mMessage;

	// The adapter is created when we call RequestAdapter(F). It is guaranteed to be alive
	// throughout the duration of a RequestAdapterEvent because the Event essentially takes
	// ownership of it until either an error occurs at which point the Event cleans it up, or it
	// returns the adapter to the user who then takes ownership as the Event goes away.
	raw_ptr<Adapter> mAdapter = nullptr;
	};

	WGPUWGSLFeatureName ToWGPUFeature(tint::wgsl::LanguageFeature f) {
	switch (f) {
	#define CASE(WgslName, WgpuName) \
	case tint::wgsl::LanguageFeature::WgslName: \
	return WGPUWGSLFeatureName_##WgpuName;
	DAWN_FOREACH_WGSL_FEATURE(CASE)
	#undef CASE
	}
	}

	} // anonymous namespace

	// Instance

	Instance::Instance(const ObjectBaseParams& params) : ObjectWithEventsBase(params, params.handle) {}

	Instance::~Instance() {
	GetEventManager().TransitionTo(EventManager::State::InstanceDropped);
	}

	ObjectType Instance::GetObjectType() const {
	return ObjectType::Instance;
	}

	WireResult Instance::Initialize(const WGPUInstanceDescriptor* descriptor) {
	if (descriptor == nullptr) {
	return WireResult::Success;
	}

	if (descriptor->features.timedWaitAnyEnable) {
	dawn::ErrorLog() << "Wire client instance doesn't support timedWaitAnyEnable = true";
	return WireResult::FatalError;
	}
	if (descriptor->features.timedWaitAnyMaxCount > 0) {
	dawn::ErrorLog() << "Wire client instance doesn't support non-zero timedWaitAnyMaxCount";
	return WireResult::FatalError;
	}

	const WGPUDawnWireWGSLControl* wgslControl = nullptr;
	const WGPUDawnWGSLBlocklist* wgslBlocklist = nullptr;
	for (const WGPUChainedStruct* chain = descriptor->nextInChain; chain != nullptr;
	chain = chain->next) {
	switch (chain->sType) {
	case WGPUSType_DawnWireWGSLControl:
	wgslControl = reinterpret_cast<const WGPUDawnWireWGSLControl*>(chain);
	break;
	case WGPUSType_DawnWGSLBlocklist:
	wgslBlocklist = reinterpret_cast<const WGPUDawnWGSLBlocklist*>(chain);
	break;
	default:
	dawn::ErrorLog() << "Wire client instance doesn't support InstanceDescriptor "
	"extension structure with sType ("
	<< chain->sType << ")";
	return WireResult::FatalError;
	}
	}

	GatherWGSLFeatures(wgslControl, wgslBlocklist);

	return WireResult::Success;
	}

	void Instance::RequestAdapter(const WGPURequestAdapterOptions* options,
	WGPURequestAdapterCallback callback,
	void* userdata) {
	WGPURequestAdapterCallbackInfo callbackInfo = {};
	callbackInfo.mode = WGPUCallbackMode_AllowSpontaneous;
	callbackInfo.callback = callback;
	callbackInfo.userdata = userdata;
	RequestAdapterF(options, callbackInfo);
	}

	WGPUFuture Instance::RequestAdapterF(const WGPURequestAdapterOptions* options,
	const WGPURequestAdapterCallbackInfo& callbackInfo) {
	Client* client = GetClient();
	Adapter* adapter = client->Make<Adapter>(GetEventManagerHandle());
	auto [futureIDInternal, tracked] =
	GetEventManager().TrackEvent(std::make_unique<RequestAdapterEvent>(callbackInfo, adapter));
	if (!tracked) {
	return {futureIDInternal};
	}

	InstanceRequestAdapterCmd cmd;
	cmd.instanceId = GetWireId();
	cmd.eventManagerHandle = GetEventManagerHandle();
	cmd.future = {futureIDInternal};
	cmd.adapterObjectHandle = adapter->GetWireHandle();
	cmd.options = options;
	cmd.userdataCount = 1;

	client->SerializeCommand(cmd);
	return {futureIDInternal};
	}

	WGPUFuture Instance::RequestAdapter2(const WGPURequestAdapterOptions* options,
	const WGPURequestAdapterCallbackInfo2& callbackInfo) {
	Client* client = GetClient();
	Adapter* adapter = client->Make<Adapter>(GetEventManagerHandle());
	auto [futureIDInternal, tracked] =
	GetEventManager().TrackEvent(std::make_unique<RequestAdapterEvent>(callbackInfo, adapter));
	if (!tracked) {
	return {futureIDInternal};
	}

	InstanceRequestAdapterCmd cmd;
	cmd.instanceId = GetWireId();
	cmd.eventManagerHandle = GetEventManagerHandle();
	cmd.future = {futureIDInternal};
	cmd.adapterObjectHandle = adapter->GetWireHandle();
	cmd.options = options;
	cmd.userdataCount = 2;

	client->SerializeCommand(cmd);
	return {futureIDInternal};
	}

	WireResult Client::DoInstanceRequestAdapterCallback(ObjectHandle eventManager,
	WGPUFuture future,
	WGPURequestAdapterStatus status,
	const char* message,
	const WGPUAdapterProperties* properties,
	const WGPUSupportedLimits* limits,
	uint32_t featuresCount,
	const WGPUFeatureName* features) {
	return GetEventManager(eventManager)
	.SetFutureReady<RequestAdapterEvent>(future.id, status, message, properties, limits,
	featuresCount, features);
	}

	void Instance::ProcessEvents() {
	GetEventManager().ProcessPollEvents();

	// TODO(crbug.com/dawn/1987): The responsibility of ProcessEvents here is a bit mixed. It both
	// processes events coming in from the server, and also prompts the server to check for and
	// forward over new events - which won't be received until after this client-side
	// ProcessEvents completes.
	//
	// Fixing this nicely probably requires the server to more self-sufficiently
	// forward the events, which is half of making the wire fully invisible to use (which we might
	// like to do, someday, but not soon). This is easy for immediate events (like requestDevice)
	// and thread-driven events (async pipeline creation), but harder for queue fences where we have
	// to wait on the backend and then trigger Dawn code to forward the event.
	//
	// In the meantime, we could maybe do this on client->server flush to keep this concern in the
	// wire instead of in the API itself, but otherwise it's not significantly better so we just
	// keep it here for now for backward compatibility.
	InstanceProcessEventsCmd cmd;
	cmd.self = ToAPI(this);
	GetClient()->SerializeCommand(cmd);
	}

	WGPUWaitStatus Instance::WaitAny(size_t count, WGPUFutureWaitInfo* infos, uint64_t timeoutNS) {
	return GetEventManager().WaitAny(count, infos, timeoutNS);
	}

	void Instance::GatherWGSLFeatures(const WGPUDawnWireWGSLControl* wgslControl,
	const WGPUDawnWGSLBlocklist* wgslBlocklist) {
	WGPUDawnWireWGSLControl defaultWgslControl{};
	if (wgslControl == nullptr) {
	wgslControl = &defaultWgslControl;
	}

	for (auto wgslFeature : tint::wgsl::kAllLanguageFeatures) {
	// Skip over testing features if we don't have the toggle to expose them.
	if (!wgslControl->enableTesting) {
	switch (wgslFeature) {
	case tint::wgsl::LanguageFeature::kChromiumTestingUnimplemented:
	case tint::wgsl::LanguageFeature::kChromiumTestingUnsafeExperimental:
	case tint::wgsl::LanguageFeature::kChromiumTestingExperimental:
	case tint::wgsl::LanguageFeature::kChromiumTestingShippedWithKillswitch:
	case tint::wgsl::LanguageFeature::kChromiumTestingShipped:
	continue;
	default:
	break;
	}
	}

	// Expose the feature depending on its status and wgslControl.
	bool enable = false;
	switch (tint::wgsl::GetLanguageFeatureStatus(wgslFeature)) {
	case tint::wgsl::FeatureStatus::kUnknown:
	case tint::wgsl::FeatureStatus::kUnimplemented:
	enable = false;
	break;

	case tint::wgsl::FeatureStatus::kUnsafeExperimental:
	enable = wgslControl->enableUnsafe;
	break;
	case tint::wgsl::FeatureStatus::kExperimental:
	enable = wgslControl->enableExperimental;
	break;

	case tint::wgsl::FeatureStatus::kShippedWithKillswitch:
	case tint::wgsl::FeatureStatus::kShipped:
	enable = true;
	break;
	}

	if (enable) {
	mWGSLFeatures.emplace(ToWGPUFeature(wgslFeature));
	}
	}

	// Remove blocklisted features.
	if (wgslBlocklist != nullptr) {
	for (size_t i = 0; i < wgslBlocklist->blocklistedFeatureCount; i++) {
	const char* name = wgslBlocklist->blocklistedFeatures[i];
	tint::wgsl::LanguageFeature tintFeature = tint::wgsl::ParseLanguageFeature(name);
	WGPUWGSLFeatureName feature = ToWGPUFeature(tintFeature);

	// Ignore unknown features in the blocklist.
	if (feature == WGPUWGSLFeatureName_Undefined) {
	continue;
	}

	mWGSLFeatures.erase(feature);
	}
	}
	}

	bool Instance::HasWGSLLanguageFeature(WGPUWGSLFeatureName feature) const {
	return mWGSLFeatures.contains(feature);
	}

	size_t Instance::EnumerateWGSLLanguageFeatures(WGPUWGSLFeatureName* features) const {
	if (features != nullptr) {
	for (WGPUWGSLFeatureName f : mWGSLFeatures) {
	*features = f;
	++features;
	}
	}
	return mWGSLFeatures.size();
	}

	} // namespace dawn::wire::client

	// Free-standing API functions

	DAWN_WIRE_EXPORT WGPUStatus wgpuDawnWireClientGetInstanceFeatures(WGPUInstanceFeatures* features) {
	if (features->nextInChain != nullptr) {
	return WGPUStatus_Error;
	}

	features->timedWaitAnyEnable = false;
	features->timedWaitAnyMaxCount = dawn::kTimedWaitAnyMaxCountDefault;
	return WGPUStatus_Success;
	}

	DAWN_WIRE_EXPORT WGPUInstance
	wgpuDawnWireClientCreateInstance(WGPUInstanceDescriptor const* descriptor) {
	DAWN_UNREACHABLE();
	return nullptr;
	}