Project template

vendor/zgpu/libs/dawn/include/dawn/EnumClassBitmasks.h

@@ -0,0 +1,148 @@
+// Copyright 2017 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_ENUMCLASSBITMASKS_H_
+#define INCLUDE_DAWN_ENUMCLASSBITMASKS_H_
+
+#include <type_traits>
+
+// The operators in dawn:: namespace need be introduced into other namespaces with
+// using-declarations for C++ Argument Dependent Lookup to work.
+#define DAWN_IMPORT_BITMASK_OPERATORS \
+    using dawn::operator|;            \
+    using dawn::operator&;            \
+    using dawn::operator^;            \
+    using dawn::operator~;            \
+    using dawn::operator&=;           \
+    using dawn::operator|=;           \
+    using dawn::operator^=;           \
+    using dawn::HasZeroOrOneBits;
+
+namespace dawn {
+
+template <typename T>
+struct IsDawnBitmask {
+    static constexpr bool enable = false;
+};
+
+template <typename T, typename Enable = void>
+struct LowerBitmask {
+    static constexpr bool enable = false;
+};
+
+template <typename T>
+struct LowerBitmask<T, typename std::enable_if<IsDawnBitmask<T>::enable>::type> {
+    static constexpr bool enable = true;
+    using type = T;
+    constexpr static T Lower(T t) { return t; }
+};
+
+template <typename T>
+struct BoolConvertible {
+    using Integral = typename std::underlying_type<T>::type;
+
+    // NOLINTNEXTLINE(runtime/explicit)
+    explicit constexpr BoolConvertible(Integral value) : value(value) {}
+    constexpr operator bool() const { return value != 0; }
+    constexpr operator T() const { return static_cast<T>(value); }
+
+    Integral value;
+};
+
+template <typename T>
+struct LowerBitmask<BoolConvertible<T>> {
+    static constexpr bool enable = true;
+    using type = T;
+    static constexpr type Lower(BoolConvertible<T> t) { return t; }
+};
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator|(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) |
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator&(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) &
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator^(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) ^
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <typename T1>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator~(T1 t) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(~static_cast<Integral>(LowerBitmask<T1>::Lower(t)));
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsDawnBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator&=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l & r;
+    return l;
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsDawnBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator|=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l | r;
+    return l;
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsDawnBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator^=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l ^ r;
+    return l;
+}
+
+template <typename T>
+constexpr bool HasZeroOrOneBits(T value) {
+    using Integral = typename std::underlying_type<T>::type;
+    return (static_cast<Integral>(value) & (static_cast<Integral>(value) - 1)) == 0;
+}
+
+}  // namespace dawn
+
+#endif  // INCLUDE_DAWN_ENUMCLASSBITMASKS_H_

vendor/zgpu/libs/dawn/include/dawn/dawn_proc.h

@@ -0,0 +1,36 @@
+// Copyright 2019 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_DAWN_PROC_H_
+#define INCLUDE_DAWN_DAWN_PROC_H_
+
+#include "dawn/dawn_proc_table.h"
+#include "dawn/webgpu.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Sets the static proctable used by libdawn_proc to implement the Dawn entrypoints. Passing NULL
+// for `procs` sets up the null proctable that contains only null function pointers. It is the
+// default value of the proctable. Setting the proctable back to null is good practice when you
+// are done using libdawn_proc since further usage will cause a segfault instead of calling an
+// unexpected function.
+WGPU_EXPORT void dawnProcSetProcs(const DawnProcTable* procs);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // INCLUDE_DAWN_DAWN_PROC_H_

vendor/zgpu/libs/dawn/include/dawn/dawn_proc_table.h

@@ -0,0 +1,245 @@
+
+#ifndef DAWN_DAWN_PROC_TABLE_H_
+#define DAWN_DAWN_PROC_TABLE_H_
+
+#include "dawn/webgpu.h"
+
+// Note: Often allocated as a static global. Do not add a complex constructor.
+typedef struct DawnProcTable {
+    WGPUProcCreateInstance createInstance;
+    WGPUProcGetProcAddress getProcAddress;
+
+    WGPUProcAdapterCreateDevice adapterCreateDevice;
+    WGPUProcAdapterEnumerateFeatures adapterEnumerateFeatures;
+    WGPUProcAdapterGetInstance adapterGetInstance;
+    WGPUProcAdapterGetLimits adapterGetLimits;
+    WGPUProcAdapterGetProperties adapterGetProperties;
+    WGPUProcAdapterHasFeature adapterHasFeature;
+    WGPUProcAdapterRequestDevice adapterRequestDevice;
+    WGPUProcAdapterReference adapterReference;
+    WGPUProcAdapterRelease adapterRelease;
+
+    WGPUProcBindGroupSetLabel bindGroupSetLabel;
+    WGPUProcBindGroupReference bindGroupReference;
+    WGPUProcBindGroupRelease bindGroupRelease;
+
+    WGPUProcBindGroupLayoutSetLabel bindGroupLayoutSetLabel;
+    WGPUProcBindGroupLayoutReference bindGroupLayoutReference;
+    WGPUProcBindGroupLayoutRelease bindGroupLayoutRelease;
+
+    WGPUProcBufferDestroy bufferDestroy;
+    WGPUProcBufferGetConstMappedRange bufferGetConstMappedRange;
+    WGPUProcBufferGetMapState bufferGetMapState;
+    WGPUProcBufferGetMappedRange bufferGetMappedRange;
+    WGPUProcBufferGetSize bufferGetSize;
+    WGPUProcBufferGetUsage bufferGetUsage;
+    WGPUProcBufferMapAsync bufferMapAsync;
+    WGPUProcBufferSetLabel bufferSetLabel;
+    WGPUProcBufferUnmap bufferUnmap;
+    WGPUProcBufferReference bufferReference;
+    WGPUProcBufferRelease bufferRelease;
+
+    WGPUProcCommandBufferSetLabel commandBufferSetLabel;
+    WGPUProcCommandBufferReference commandBufferReference;
+    WGPUProcCommandBufferRelease commandBufferRelease;
+
+    WGPUProcCommandEncoderBeginComputePass commandEncoderBeginComputePass;
+    WGPUProcCommandEncoderBeginRenderPass commandEncoderBeginRenderPass;
+    WGPUProcCommandEncoderClearBuffer commandEncoderClearBuffer;
+    WGPUProcCommandEncoderCopyBufferToBuffer commandEncoderCopyBufferToBuffer;
+    WGPUProcCommandEncoderCopyBufferToTexture commandEncoderCopyBufferToTexture;
+    WGPUProcCommandEncoderCopyTextureToBuffer commandEncoderCopyTextureToBuffer;
+    WGPUProcCommandEncoderCopyTextureToTexture commandEncoderCopyTextureToTexture;
+    WGPUProcCommandEncoderCopyTextureToTextureInternal commandEncoderCopyTextureToTextureInternal;
+    WGPUProcCommandEncoderFinish commandEncoderFinish;
+    WGPUProcCommandEncoderInjectValidationError commandEncoderInjectValidationError;
+    WGPUProcCommandEncoderInsertDebugMarker commandEncoderInsertDebugMarker;
+    WGPUProcCommandEncoderPopDebugGroup commandEncoderPopDebugGroup;
+    WGPUProcCommandEncoderPushDebugGroup commandEncoderPushDebugGroup;
+    WGPUProcCommandEncoderResolveQuerySet commandEncoderResolveQuerySet;
+    WGPUProcCommandEncoderSetLabel commandEncoderSetLabel;
+    WGPUProcCommandEncoderWriteBuffer commandEncoderWriteBuffer;
+    WGPUProcCommandEncoderWriteTimestamp commandEncoderWriteTimestamp;
+    WGPUProcCommandEncoderReference commandEncoderReference;
+    WGPUProcCommandEncoderRelease commandEncoderRelease;
+
+    WGPUProcComputePassEncoderDispatchWorkgroups computePassEncoderDispatchWorkgroups;
+    WGPUProcComputePassEncoderDispatchWorkgroupsIndirect computePassEncoderDispatchWorkgroupsIndirect;
+    WGPUProcComputePassEncoderEnd computePassEncoderEnd;
+    WGPUProcComputePassEncoderInsertDebugMarker computePassEncoderInsertDebugMarker;
+    WGPUProcComputePassEncoderPopDebugGroup computePassEncoderPopDebugGroup;
+    WGPUProcComputePassEncoderPushDebugGroup computePassEncoderPushDebugGroup;
+    WGPUProcComputePassEncoderSetBindGroup computePassEncoderSetBindGroup;
+    WGPUProcComputePassEncoderSetLabel computePassEncoderSetLabel;
+    WGPUProcComputePassEncoderSetPipeline computePassEncoderSetPipeline;
+    WGPUProcComputePassEncoderWriteTimestamp computePassEncoderWriteTimestamp;
+    WGPUProcComputePassEncoderReference computePassEncoderReference;
+    WGPUProcComputePassEncoderRelease computePassEncoderRelease;
+
+    WGPUProcComputePipelineGetBindGroupLayout computePipelineGetBindGroupLayout;
+    WGPUProcComputePipelineSetLabel computePipelineSetLabel;
+    WGPUProcComputePipelineReference computePipelineReference;
+    WGPUProcComputePipelineRelease computePipelineRelease;
+
+    WGPUProcDeviceCreateBindGroup deviceCreateBindGroup;
+    WGPUProcDeviceCreateBindGroupLayout deviceCreateBindGroupLayout;
+    WGPUProcDeviceCreateBuffer deviceCreateBuffer;
+    WGPUProcDeviceCreateCommandEncoder deviceCreateCommandEncoder;
+    WGPUProcDeviceCreateComputePipeline deviceCreateComputePipeline;
+    WGPUProcDeviceCreateComputePipelineAsync deviceCreateComputePipelineAsync;
+    WGPUProcDeviceCreateErrorBuffer deviceCreateErrorBuffer;
+    WGPUProcDeviceCreateErrorExternalTexture deviceCreateErrorExternalTexture;
+    WGPUProcDeviceCreateErrorShaderModule deviceCreateErrorShaderModule;
+    WGPUProcDeviceCreateErrorTexture deviceCreateErrorTexture;
+    WGPUProcDeviceCreateExternalTexture deviceCreateExternalTexture;
+    WGPUProcDeviceCreatePipelineLayout deviceCreatePipelineLayout;
+    WGPUProcDeviceCreateQuerySet deviceCreateQuerySet;
+    WGPUProcDeviceCreateRenderBundleEncoder deviceCreateRenderBundleEncoder;
+    WGPUProcDeviceCreateRenderPipeline deviceCreateRenderPipeline;
+    WGPUProcDeviceCreateRenderPipelineAsync deviceCreateRenderPipelineAsync;
+    WGPUProcDeviceCreateSampler deviceCreateSampler;
+    WGPUProcDeviceCreateShaderModule deviceCreateShaderModule;
+    WGPUProcDeviceCreateSwapChain deviceCreateSwapChain;
+    WGPUProcDeviceCreateTexture deviceCreateTexture;
+    WGPUProcDeviceDestroy deviceDestroy;
+    WGPUProcDeviceEnumerateFeatures deviceEnumerateFeatures;
+    WGPUProcDeviceForceLoss deviceForceLoss;
+    WGPUProcDeviceGetAdapter deviceGetAdapter;
+    WGPUProcDeviceGetLimits deviceGetLimits;
+    WGPUProcDeviceGetQueue deviceGetQueue;
+    WGPUProcDeviceGetSupportedSurfaceUsage deviceGetSupportedSurfaceUsage;
+    WGPUProcDeviceHasFeature deviceHasFeature;
+    WGPUProcDeviceInjectError deviceInjectError;
+    WGPUProcDevicePopErrorScope devicePopErrorScope;
+    WGPUProcDevicePushErrorScope devicePushErrorScope;
+    WGPUProcDeviceSetDeviceLostCallback deviceSetDeviceLostCallback;
+    WGPUProcDeviceSetLabel deviceSetLabel;
+    WGPUProcDeviceSetLoggingCallback deviceSetLoggingCallback;
+    WGPUProcDeviceSetUncapturedErrorCallback deviceSetUncapturedErrorCallback;
+    WGPUProcDeviceTick deviceTick;
+    WGPUProcDeviceValidateTextureDescriptor deviceValidateTextureDescriptor;
+    WGPUProcDeviceReference deviceReference;
+    WGPUProcDeviceRelease deviceRelease;
+
+    WGPUProcExternalTextureDestroy externalTextureDestroy;
+    WGPUProcExternalTextureExpire externalTextureExpire;
+    WGPUProcExternalTextureRefresh externalTextureRefresh;
+    WGPUProcExternalTextureSetLabel externalTextureSetLabel;
+    WGPUProcExternalTextureReference externalTextureReference;
+    WGPUProcExternalTextureRelease externalTextureRelease;
+
+    WGPUProcInstanceCreateSurface instanceCreateSurface;
+    WGPUProcInstanceProcessEvents instanceProcessEvents;
+    WGPUProcInstanceRequestAdapter instanceRequestAdapter;
+    WGPUProcInstanceReference instanceReference;
+    WGPUProcInstanceRelease instanceRelease;
+
+    WGPUProcPipelineLayoutSetLabel pipelineLayoutSetLabel;
+    WGPUProcPipelineLayoutReference pipelineLayoutReference;
+    WGPUProcPipelineLayoutRelease pipelineLayoutRelease;
+
+    WGPUProcQuerySetDestroy querySetDestroy;
+    WGPUProcQuerySetGetCount querySetGetCount;
+    WGPUProcQuerySetGetType querySetGetType;
+    WGPUProcQuerySetSetLabel querySetSetLabel;
+    WGPUProcQuerySetReference querySetReference;
+    WGPUProcQuerySetRelease querySetRelease;
+
+    WGPUProcQueueCopyExternalTextureForBrowser queueCopyExternalTextureForBrowser;
+    WGPUProcQueueCopyTextureForBrowser queueCopyTextureForBrowser;
+    WGPUProcQueueOnSubmittedWorkDone queueOnSubmittedWorkDone;
+    WGPUProcQueueSetLabel queueSetLabel;
+    WGPUProcQueueSubmit queueSubmit;
+    WGPUProcQueueWriteBuffer queueWriteBuffer;
+    WGPUProcQueueWriteTexture queueWriteTexture;
+    WGPUProcQueueReference queueReference;
+    WGPUProcQueueRelease queueRelease;
+
+    WGPUProcRenderBundleSetLabel renderBundleSetLabel;
+    WGPUProcRenderBundleReference renderBundleReference;
+    WGPUProcRenderBundleRelease renderBundleRelease;
+
+    WGPUProcRenderBundleEncoderDraw renderBundleEncoderDraw;
+    WGPUProcRenderBundleEncoderDrawIndexed renderBundleEncoderDrawIndexed;
+    WGPUProcRenderBundleEncoderDrawIndexedIndirect renderBundleEncoderDrawIndexedIndirect;
+    WGPUProcRenderBundleEncoderDrawIndirect renderBundleEncoderDrawIndirect;
+    WGPUProcRenderBundleEncoderFinish renderBundleEncoderFinish;
+    WGPUProcRenderBundleEncoderInsertDebugMarker renderBundleEncoderInsertDebugMarker;
+    WGPUProcRenderBundleEncoderPopDebugGroup renderBundleEncoderPopDebugGroup;
+    WGPUProcRenderBundleEncoderPushDebugGroup renderBundleEncoderPushDebugGroup;
+    WGPUProcRenderBundleEncoderSetBindGroup renderBundleEncoderSetBindGroup;
+    WGPUProcRenderBundleEncoderSetIndexBuffer renderBundleEncoderSetIndexBuffer;
+    WGPUProcRenderBundleEncoderSetLabel renderBundleEncoderSetLabel;
+    WGPUProcRenderBundleEncoderSetPipeline renderBundleEncoderSetPipeline;
+    WGPUProcRenderBundleEncoderSetVertexBuffer renderBundleEncoderSetVertexBuffer;
+    WGPUProcRenderBundleEncoderReference renderBundleEncoderReference;
+    WGPUProcRenderBundleEncoderRelease renderBundleEncoderRelease;
+
+    WGPUProcRenderPassEncoderBeginOcclusionQuery renderPassEncoderBeginOcclusionQuery;
+    WGPUProcRenderPassEncoderDraw renderPassEncoderDraw;
+    WGPUProcRenderPassEncoderDrawIndexed renderPassEncoderDrawIndexed;
+    WGPUProcRenderPassEncoderDrawIndexedIndirect renderPassEncoderDrawIndexedIndirect;
+    WGPUProcRenderPassEncoderDrawIndirect renderPassEncoderDrawIndirect;
+    WGPUProcRenderPassEncoderEnd renderPassEncoderEnd;
+    WGPUProcRenderPassEncoderEndOcclusionQuery renderPassEncoderEndOcclusionQuery;
+    WGPUProcRenderPassEncoderExecuteBundles renderPassEncoderExecuteBundles;
+    WGPUProcRenderPassEncoderInsertDebugMarker renderPassEncoderInsertDebugMarker;
+    WGPUProcRenderPassEncoderPopDebugGroup renderPassEncoderPopDebugGroup;
+    WGPUProcRenderPassEncoderPushDebugGroup renderPassEncoderPushDebugGroup;
+    WGPUProcRenderPassEncoderSetBindGroup renderPassEncoderSetBindGroup;
+    WGPUProcRenderPassEncoderSetBlendConstant renderPassEncoderSetBlendConstant;
+    WGPUProcRenderPassEncoderSetIndexBuffer renderPassEncoderSetIndexBuffer;
+    WGPUProcRenderPassEncoderSetLabel renderPassEncoderSetLabel;
+    WGPUProcRenderPassEncoderSetPipeline renderPassEncoderSetPipeline;
+    WGPUProcRenderPassEncoderSetScissorRect renderPassEncoderSetScissorRect;
+    WGPUProcRenderPassEncoderSetStencilReference renderPassEncoderSetStencilReference;
+    WGPUProcRenderPassEncoderSetVertexBuffer renderPassEncoderSetVertexBuffer;
+    WGPUProcRenderPassEncoderSetViewport renderPassEncoderSetViewport;
+    WGPUProcRenderPassEncoderWriteTimestamp renderPassEncoderWriteTimestamp;
+    WGPUProcRenderPassEncoderReference renderPassEncoderReference;
+    WGPUProcRenderPassEncoderRelease renderPassEncoderRelease;
+
+    WGPUProcRenderPipelineGetBindGroupLayout renderPipelineGetBindGroupLayout;
+    WGPUProcRenderPipelineSetLabel renderPipelineSetLabel;
+    WGPUProcRenderPipelineReference renderPipelineReference;
+    WGPUProcRenderPipelineRelease renderPipelineRelease;
+
+    WGPUProcSamplerSetLabel samplerSetLabel;
+    WGPUProcSamplerReference samplerReference;
+    WGPUProcSamplerRelease samplerRelease;
+
+    WGPUProcShaderModuleGetCompilationInfo shaderModuleGetCompilationInfo;
+    WGPUProcShaderModuleSetLabel shaderModuleSetLabel;
+    WGPUProcShaderModuleReference shaderModuleReference;
+    WGPUProcShaderModuleRelease shaderModuleRelease;
+
+    WGPUProcSurfaceReference surfaceReference;
+    WGPUProcSurfaceRelease surfaceRelease;
+
+    WGPUProcSwapChainGetCurrentTexture swapChainGetCurrentTexture;
+    WGPUProcSwapChainGetCurrentTextureView swapChainGetCurrentTextureView;
+    WGPUProcSwapChainPresent swapChainPresent;
+    WGPUProcSwapChainReference swapChainReference;
+    WGPUProcSwapChainRelease swapChainRelease;
+
+    WGPUProcTextureCreateView textureCreateView;
+    WGPUProcTextureDestroy textureDestroy;
+    WGPUProcTextureGetDepthOrArrayLayers textureGetDepthOrArrayLayers;
+    WGPUProcTextureGetDimension textureGetDimension;
+    WGPUProcTextureGetFormat textureGetFormat;
+    WGPUProcTextureGetHeight textureGetHeight;
+    WGPUProcTextureGetMipLevelCount textureGetMipLevelCount;
+    WGPUProcTextureGetSampleCount textureGetSampleCount;
+    WGPUProcTextureGetUsage textureGetUsage;
+    WGPUProcTextureGetWidth textureGetWidth;
+    WGPUProcTextureSetLabel textureSetLabel;
+    WGPUProcTextureReference textureReference;
+    WGPUProcTextureRelease textureRelease;
+
+    WGPUProcTextureViewSetLabel textureViewSetLabel;
+    WGPUProcTextureViewReference textureViewReference;
+    WGPUProcTextureViewRelease textureViewRelease;
+
+} DawnProcTable;
+
+#endif  // DAWN_DAWN_PROC_TABLE_H_

vendor/zgpu/libs/dawn/include/dawn/dawn_thread_dispatch_proc.h

@@ -0,0 +1,33 @@
+// Copyright 2020 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_DAWN_THREAD_DISPATCH_PROC_H_
+#define INCLUDE_DAWN_DAWN_THREAD_DISPATCH_PROC_H_
+
+#include "dawn/dawn_proc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Call dawnProcSetProcs(&dawnThreadDispatchProcTable) and then use dawnProcSetPerThreadProcs
+// to set per-thread procs.
+WGPU_EXPORT extern DawnProcTable dawnThreadDispatchProcTable;
+WGPU_EXPORT void dawnProcSetPerThreadProcs(const DawnProcTable* procs);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // INCLUDE_DAWN_DAWN_THREAD_DISPATCH_PROC_H_

vendor/zgpu/libs/dawn/include/dawn/native/D3D11Backend.h

@@ -0,0 +1,41 @@
+// Copyright 2023 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_D3D11BACKEND_H_
+#define INCLUDE_DAWN_NATIVE_D3D11BACKEND_H_
+
+#include <d3d11_1.h>
+#include <windows.h>
+#include <wrl/client.h>
+
+#include <memory>
+
+#include "dawn/native/D3DBackend.h"
+
+namespace dawn::native::d3d11 {
+
+struct DAWN_NATIVE_EXPORT PhysicalDeviceDiscoveryOptions
+    : public d3d::PhysicalDeviceDiscoveryOptions {
+    PhysicalDeviceDiscoveryOptions();
+    explicit PhysicalDeviceDiscoveryOptions(Microsoft::WRL::ComPtr<IDXGIAdapter> adapter);
+};
+
+// TODO(dawn:1774): Deprecated.
+using AdapterDiscoveryOptions = PhysicalDeviceDiscoveryOptions;
+
+DAWN_NATIVE_EXPORT Microsoft::WRL::ComPtr<ID3D11Device> GetD3D11Device(WGPUDevice device);
+
+}  // namespace dawn::native::d3d11
+
+#endif  // INCLUDE_DAWN_NATIVE_D3D11BACKEND_H_

vendor/zgpu/libs/dawn/include/dawn/native/D3D12Backend.h

@@ -0,0 +1,52 @@
+// Copyright 2018 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_D3D12BACKEND_H_
+#define INCLUDE_DAWN_NATIVE_D3D12BACKEND_H_
+
+#include <DXGI1_4.h>
+#include <d3d12.h>
+#include <windows.h>
+#include <wrl/client.h>
+
+#include "dawn/native/D3DBackend.h"
+
+struct ID3D12Device;
+struct ID3D12Resource;
+
+namespace dawn::native::d3d12 {
+
+class Device;
+
+enum MemorySegment {
+    Local,
+    NonLocal,
+};
+
+DAWN_NATIVE_EXPORT uint64_t SetExternalMemoryReservation(WGPUDevice device,
+                                                         uint64_t requestedReservationSize,
+                                                         MemorySegment memorySegment);
+
+struct DAWN_NATIVE_EXPORT PhysicalDeviceDiscoveryOptions
+    : public d3d::PhysicalDeviceDiscoveryOptions {
+    PhysicalDeviceDiscoveryOptions();
+    explicit PhysicalDeviceDiscoveryOptions(Microsoft::WRL::ComPtr<IDXGIAdapter> adapter);
+};
+
+// TODO(dawn:1774): Deprecated.
+using AdapterDiscoveryOptions = PhysicalDeviceDiscoveryOptions;
+
+}  // namespace dawn::native::d3d12
+
+#endif  // INCLUDE_DAWN_NATIVE_D3D12BACKEND_H_

vendor/zgpu/libs/dawn/include/dawn/native/D3DBackend.h

@@ -0,0 +1,109 @@
+// Copyright 2023 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_D3DBACKEND_H_
+#define INCLUDE_DAWN_NATIVE_D3DBACKEND_H_
+
+#include <dxgi1_4.h>
+#include <windows.h>
+#include <wrl/client.h>
+
+#include <memory>
+#include <vector>
+
+#include "dawn/native/DawnNative.h"
+#include "dawn/webgpu_cpp_chained_struct.h"
+
+namespace dawn::native::d3d {
+
+class ExternalImageDXGIImpl;
+
+DAWN_NATIVE_EXPORT Microsoft::WRL::ComPtr<IDXGIAdapter> GetDXGIAdapter(WGPUAdapter adapter);
+
+// Can be chained in WGPURequestAdapterOptions
+struct DAWN_NATIVE_EXPORT RequestAdapterOptionsLUID : wgpu::ChainedStruct {
+    RequestAdapterOptionsLUID();
+
+    ::LUID adapterLUID;
+};
+
+struct DAWN_NATIVE_EXPORT PhysicalDeviceDiscoveryOptions
+    : public PhysicalDeviceDiscoveryOptionsBase {
+    PhysicalDeviceDiscoveryOptions(WGPUBackendType type,
+                                   Microsoft::WRL::ComPtr<IDXGIAdapter> adapter);
+    Microsoft::WRL::ComPtr<IDXGIAdapter> dxgiAdapter;
+};
+
+// TODO(dawn:1774): Deprecated.
+using AdapterDiscoveryOptions = PhysicalDeviceDiscoveryOptions;
+
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptorDXGISharedHandle : ExternalImageDescriptor {
+  public:
+    ExternalImageDescriptorDXGISharedHandle();
+
+    // Note: SharedHandle must be a handle to a texture object.
+    HANDLE sharedHandle = nullptr;
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageDXGIFenceDescriptor {
+    // Shared handle for the fence. This never passes ownership to the callee (when used as an input
+    // parameter) or to the caller (when used as a return value or output parameter).
+    HANDLE fenceHandle = nullptr;
+
+    // The value that was previously signaled on this fence and should be waited on.
+    uint64_t fenceValue = 0;
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageDXGIBeginAccessDescriptor {
+    bool isInitialized = false;  // Whether the texture is initialized on import
+    WGPUTextureUsageFlags usage = WGPUTextureUsage_None;
+
+    // A list of fences to wait on before accessing the texture.
+    std::vector<ExternalImageDXGIFenceDescriptor> waitFences;
+
+    // Whether the texture is for a WebGPU swap chain.
+    bool isSwapChainTexture = false;
+};
+
+class DAWN_NATIVE_EXPORT ExternalImageDXGI {
+  public:
+    ~ExternalImageDXGI();
+
+    static std::unique_ptr<ExternalImageDXGI> Create(
+        WGPUDevice device,
+        const ExternalImageDescriptorDXGISharedHandle* descriptor);
+
+    // Returns true if the external image resources are still valid, otherwise BeginAccess() is
+    // guaranteed to fail e.g. after device destruction.
+    bool IsValid() const;
+
+    // Creates WGPUTexture wrapping the DXGI shared handle. The provided wait fences will be
+    // synchronized before using the texture in any command lists. Empty fences (nullptr handle) are
+    // ignored for convenience (EndAccess can return such fences).
+    WGPUTexture BeginAccess(const ExternalImageDXGIBeginAccessDescriptor* descriptor);
+
+    // Returns the signalFence that the client must wait on for correct synchronization. Can return
+    // an empty fence (nullptr handle) if the texture wasn't accessed by Dawn.
+    // Note that merely calling Destroy() on the WGPUTexture does not ensure synchronization.
+    void EndAccess(WGPUTexture texture, ExternalImageDXGIFenceDescriptor* signalFence);
+
+  private:
+    explicit ExternalImageDXGI(std::unique_ptr<ExternalImageDXGIImpl> impl);
+
+    std::unique_ptr<ExternalImageDXGIImpl> mImpl;
+};
+
+}  // namespace dawn::native::d3d
+
+#endif  // INCLUDE_DAWN_NATIVE_D3DBACKEND_H_

vendor/zgpu/libs/dawn/include/dawn/native/DawnNative.h

@@ -0,0 +1,309 @@
+// Copyright 2018 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_DAWNNATIVE_H_
+#define INCLUDE_DAWN_NATIVE_DAWNNATIVE_H_
+
+#include <string>
+#include <vector>
+
+#include "dawn/dawn_proc_table.h"
+#include "dawn/native/dawn_native_export.h"
+#include "dawn/webgpu.h"
+#include "dawn/webgpu_cpp_chained_struct.h"
+
+namespace dawn::platform {
+class Platform;
+}  // namespace dawn::platform
+
+namespace wgpu {
+struct AdapterProperties;
+struct DeviceDescriptor;
+struct RequestAdapterOptions;
+}  // namespace wgpu
+
+namespace dawn::native {
+
+class InstanceBase;
+class AdapterBase;
+
+// Each toggle is assigned with a TogglesStage, indicating the validation and earliest usage
+// time of the toggle.
+enum class ToggleStage { Instance, Adapter, Device };
+
+// A struct to record the information of a toggle. A toggle is a code path in Dawn device that
+// can be manually configured to run or not outside Dawn, including workarounds, special
+// features and optimizations.
+struct ToggleInfo {
+    const char* name;
+    const char* description;
+    const char* url;
+    ToggleStage stage;
+};
+
+// A struct to record the information of a feature. A feature is a GPU feature that is not
+// required to be supported by all Dawn backends and can only be used when it is enabled on the
+// creation of device.
+struct FeatureInfo {
+    const char* name;
+    const char* description;
+    const char* url;
+    // The enum of feature state, could be stable or experimental. Using an experimental feature
+    // requires the AllowUnsafeAPIs toggle to be enabled.
+    enum class FeatureState { Stable = 0, Experimental };
+    FeatureState featureState;
+};
+
+// An adapter is an object that represent on possibility of creating devices in the system.
+// Most of the time it will represent a combination of a physical GPU and an API. Not that the
+// same GPU can be represented by multiple adapters but on different APIs.
+//
+// The underlying Dawn adapter is owned by the Dawn instance so this class is not RAII but just
+// a reference to an underlying adapter.
+class DAWN_NATIVE_EXPORT Adapter {
+  public:
+    Adapter();
+    // NOLINTNEXTLINE(runtime/explicit)
+    Adapter(AdapterBase* impl);
+    ~Adapter();
+
+    Adapter(const Adapter& other);
+    Adapter& operator=(const Adapter& other);
+
+    // Essentially webgpu.h's wgpuAdapterGetProperties while we don't have WGPUAdapter in
+    // dawn.json
+    void GetProperties(wgpu::AdapterProperties* properties) const;
+    void GetProperties(WGPUAdapterProperties* properties) const;
+
+    std::vector<const char*> GetSupportedExtensions() const;
+    std::vector<const char*> GetSupportedFeatures() const;
+    bool GetLimits(WGPUSupportedLimits* limits) const;
+
+    void SetUseTieredLimits(bool useTieredLimits);
+
+    // Check that the Adapter is able to support importing external images. This is necessary
+    // to implement the swapchain and interop APIs in Chromium.
+    bool SupportsExternalImages() const;
+
+    explicit operator bool() const;
+
+    // Create a device on this adapter. On an error, nullptr is returned.
+    WGPUDevice CreateDevice(const wgpu::DeviceDescriptor* deviceDescriptor);
+    WGPUDevice CreateDevice(const WGPUDeviceDescriptor* deviceDescriptor = nullptr);
+
+    void RequestDevice(const wgpu::DeviceDescriptor* descriptor,
+                       WGPURequestDeviceCallback callback,
+                       void* userdata);
+    void RequestDevice(const WGPUDeviceDescriptor* descriptor,
+                       WGPURequestDeviceCallback callback,
+                       void* userdata);
+    void RequestDevice(std::nullptr_t descriptor,
+                       WGPURequestDeviceCallback callback,
+                       void* userdata) {
+        RequestDevice(static_cast<const wgpu::DeviceDescriptor*>(descriptor), callback, userdata);
+    }
+
+    // Returns the underlying WGPUAdapter object.
+    WGPUAdapter Get() const;
+
+    // Reset the backend device object for testing purposes.
+    void ResetInternalDeviceForTesting();
+
+  private:
+    AdapterBase* mImpl = nullptr;
+};
+
+// Base class for options passed to Instance::DiscoverPhysicalDevices.
+struct DAWN_NATIVE_EXPORT PhysicalDeviceDiscoveryOptionsBase {
+  public:
+    const WGPUBackendType backendType;
+
+  protected:
+    explicit PhysicalDeviceDiscoveryOptionsBase(WGPUBackendType type);
+};
+
+// Deprecated, use PhysicalDeviceDiscoveryOptionsBase instead.
+// TODO(dawn:1774): Remove this.
+using AdapterDiscoveryOptionsBase = PhysicalDeviceDiscoveryOptionsBase;
+
+enum BackendValidationLevel { Full, Partial, Disabled };
+
+// Can be chained in InstanceDescriptor
+struct DAWN_NATIVE_EXPORT DawnInstanceDescriptor : wgpu::ChainedStruct {
+    DawnInstanceDescriptor();
+    static constexpr size_t kFirstMemberAlignment =
+        wgpu::detail::ConstexprMax(alignof(wgpu::ChainedStruct), alignof(uint32_t));
+    alignas(kFirstMemberAlignment) uint32_t additionalRuntimeSearchPathsCount = 0;
+    const char* const* additionalRuntimeSearchPaths;
+    dawn::platform::Platform* platform = nullptr;
+
+    // Equality operators, mostly for testing. Note that this tests
+    // strict pointer-pointer equality if the struct contains member pointers.
+    bool operator==(const DawnInstanceDescriptor& rhs) const;
+};
+
+// Represents a connection to dawn_native and is used for dependency injection, discovering
+// system adapters and injecting custom adapters (like a Swiftshader Vulkan adapter).
+//
+// This is an RAII class for Dawn instances and also controls the lifetime of all adapters
+// for this instance.
+class DAWN_NATIVE_EXPORT Instance {
+  public:
+    explicit Instance(const WGPUInstanceDescriptor* desc = nullptr);
+    ~Instance();
+
+    Instance(const Instance& other) = delete;
+    Instance& operator=(const Instance& other) = delete;
+
+    // Gather all physical devices in the system that can be accessed with no special options.
+    void DiscoverDefaultPhysicalDevices();
+
+    // Adds physical devices that can be discovered with the options provided (like a
+    // getProcAddress). The backend is chosen based on the type of the options used. Returns true on
+    // success.
+    bool DiscoverPhysicalDevices(const PhysicalDeviceDiscoveryOptionsBase* options);
+
+    // Deprecated, use DiscoverDefaultPhysicalDevices and DiscoverPhysicalDevices instead.
+    // TODO(Dawn:1774): Remove these.
+    void DiscoverDefaultAdapters();
+    bool DiscoverAdapters(const AdapterDiscoveryOptionsBase* options);
+
+    // Discovers and returns a vector of adapters.
+    // All systems adapters that can be found are returned if no options are passed.
+    // Otherwise, returns adapters based on the `options`. Adapter toggles descriptor can chained
+    // after options.
+    std::vector<Adapter> EnumerateAdapters(const WGPURequestAdapterOptions* options) const;
+    std::vector<Adapter> EnumerateAdapters(
+        const wgpu::RequestAdapterOptions* options = nullptr) const;
+
+    // Deprecated. Call EnumerateAdapters instead.
+    std::vector<Adapter> GetAdapters() const;
+
+    const ToggleInfo* GetToggleInfo(const char* toggleName);
+    const FeatureInfo* GetFeatureInfo(WGPUFeatureName feature);
+
+    // Enables backend validation layers
+    void EnableBackendValidation(bool enableBackendValidation);
+    void SetBackendValidationLevel(BackendValidationLevel validationLevel);
+
+    // Enable debug capture on Dawn startup
+    void EnableBeginCaptureOnStartup(bool beginCaptureOnStartup);
+
+    // Enable / disable the adapter blocklist.
+    void EnableAdapterBlocklist(bool enable);
+
+    uint64_t GetDeviceCountForTesting() const;
+
+    // Returns the underlying WGPUInstance object.
+    WGPUInstance Get() const;
+
+  private:
+    InstanceBase* mImpl = nullptr;
+};
+
+// Backend-agnostic API for dawn_native
+DAWN_NATIVE_EXPORT const DawnProcTable& GetProcs();
+
+// Query the names of all the toggles that are enabled in device
+DAWN_NATIVE_EXPORT std::vector<const char*> GetTogglesUsed(WGPUDevice device);
+
+// Backdoor to get the number of lazy clears for testing
+DAWN_NATIVE_EXPORT size_t GetLazyClearCountForTesting(WGPUDevice device);
+
+// Backdoor to get the number of deprecation warnings for testing
+DAWN_NATIVE_EXPORT size_t GetDeprecationWarningCountForTesting(WGPUDevice device);
+
+// Backdoor to get the number of physical devices an instance knows about for testing
+DAWN_NATIVE_EXPORT size_t GetPhysicalDeviceCountForTesting(WGPUInstance instance);
+
+//  Query if texture has been initialized
+DAWN_NATIVE_EXPORT bool IsTextureSubresourceInitialized(
+    WGPUTexture texture,
+    uint32_t baseMipLevel,
+    uint32_t levelCount,
+    uint32_t baseArrayLayer,
+    uint32_t layerCount,
+    WGPUTextureAspect aspect = WGPUTextureAspect_All);
+
+// Backdoor to get the order of the ProcMap for testing
+DAWN_NATIVE_EXPORT std::vector<const char*> GetProcMapNamesForTesting();
+
+DAWN_NATIVE_EXPORT bool DeviceTick(WGPUDevice device);
+
+DAWN_NATIVE_EXPORT bool InstanceProcessEvents(WGPUInstance instance);
+
+// ErrorInjector functions used for testing only. Defined in dawn_native/ErrorInjector.cpp
+DAWN_NATIVE_EXPORT void EnableErrorInjector();
+DAWN_NATIVE_EXPORT void DisableErrorInjector();
+DAWN_NATIVE_EXPORT void ClearErrorInjector();
+DAWN_NATIVE_EXPORT uint64_t AcquireErrorInjectorCallCount();
+DAWN_NATIVE_EXPORT void InjectErrorAt(uint64_t index);
+
+// The different types of external images
+enum ExternalImageType {
+    OpaqueFD,
+    DmaBuf,
+    IOSurface,
+    DXGISharedHandle,
+    EGLImage,
+    AHardwareBuffer,
+};
+
+// Common properties of external images
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptor {
+  public:
+    const WGPUTextureDescriptor* cTextureDescriptor;  // Must match image creation params
+    bool isInitialized;  // Whether the texture is initialized on import
+    ExternalImageType GetType() const;
+
+  protected:
+    explicit ExternalImageDescriptor(ExternalImageType type);
+
+  private:
+    ExternalImageType mType;
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageExportInfo {
+  public:
+    bool isInitialized = false;  // Whether the texture is initialized after export
+    ExternalImageType GetType() const;
+
+  protected:
+    explicit ExternalImageExportInfo(ExternalImageType type);
+
+  private:
+    ExternalImageType mType;
+};
+
+DAWN_NATIVE_EXPORT bool CheckIsErrorForTesting(void* objectHandle);
+
+DAWN_NATIVE_EXPORT const char* GetObjectLabelForTesting(void* objectHandle);
+
+DAWN_NATIVE_EXPORT uint64_t GetAllocatedSizeForTesting(WGPUBuffer buffer);
+
+DAWN_NATIVE_EXPORT bool BindGroupLayoutBindingsEqualForTesting(WGPUBindGroupLayout a,
+                                                               WGPUBindGroupLayout b);
+
+}  // namespace dawn::native
+
+// Alias the DawnInstanceDescriptor up to wgpu.
+// TODO(dawn:1374) Remove this aliasing once the usages are updated.
+namespace wgpu {
+using dawn::native::DawnInstanceDescriptor;
+}  // namespace wgpu
+
+// TODO(dawn:824): Remove once the deprecation period is passed.
+namespace dawn_native = dawn::native;
+
+#endif  // INCLUDE_DAWN_NATIVE_DAWNNATIVE_H_

vendor/zgpu/libs/dawn/include/dawn/native/MetalBackend.h

@@ -0,0 +1,95 @@
+// Copyright 2018 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_METALBACKEND_H_
+#define INCLUDE_DAWN_NATIVE_METALBACKEND_H_
+
+#include <vector>
+
+#include "dawn/native/DawnNative.h"
+
+// The specifics of the Metal backend expose types in function signatures that might not be
+// available in dependent's minimum supported SDK version. Suppress all availability errors using
+// clang's pragmas. Dependents using the types without guarded availability will still get errors
+// when using the types.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability"
+
+struct __IOSurface;
+typedef __IOSurface* IOSurfaceRef;
+
+#ifdef __OBJC__
+#import <Metal/Metal.h>
+#endif  // __OBJC__
+
+namespace dawn::native::metal {
+
+struct DAWN_NATIVE_EXPORT PhysicalDeviceDiscoveryOptions
+    : public PhysicalDeviceDiscoveryOptionsBase {
+    PhysicalDeviceDiscoveryOptions();
+};
+
+// TODO(dawn:1774): Deprecated.
+using AdapterDiscoveryOptions = PhysicalDeviceDiscoveryOptions;
+
+struct DAWN_NATIVE_EXPORT ExternalImageMTLSharedEventDescriptor {
+    // Shared event handle `id<MTLSharedEvent>`.
+    // This never passes ownership to the callee (when used as an input
+    // parameter) or to the caller (when used as a return value or output parameter).
+#ifdef __OBJC__
+    id<MTLSharedEvent> sharedEvent = nil;
+    static_assert(sizeof(id<MTLSharedEvent>) == sizeof(void*));
+    static_assert(alignof(id<MTLSharedEvent>) == alignof(void*));
+#else
+    void* sharedEvent = nullptr;
+#endif
+
+    // The value that was previously signaled on this event and should be waited on.
+    uint64_t signaledValue = 0;
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptorIOSurface : ExternalImageDescriptor {
+  public:
+    ExternalImageDescriptorIOSurface();
+    ~ExternalImageDescriptorIOSurface();
+
+    IOSurfaceRef ioSurface;
+
+    // A list of events to wait on before accessing the texture.
+    std::vector<ExternalImageMTLSharedEventDescriptor> waitEvents;
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageIOSurfaceEndAccessDescriptor
+    : ExternalImageMTLSharedEventDescriptor {
+    bool isInitialized;
+};
+
+DAWN_NATIVE_EXPORT WGPUTexture WrapIOSurface(WGPUDevice device,
+                                             const ExternalImageDescriptorIOSurface* descriptor);
+
+DAWN_NATIVE_EXPORT void IOSurfaceEndAccess(WGPUTexture texture,
+                                           ExternalImageIOSurfaceEndAccessDescriptor* descriptor);
+
+// When making Metal interop with other APIs, we need to be careful that QueueSubmit doesn't
+// mean that the operations will be visible to other APIs/Metal devices right away. macOS
+// does have a global queue of graphics operations, but the command buffers are inserted there
+// when they are "scheduled". Submitting other operations before the command buffer is
+// scheduled could lead to races in who gets scheduled first and incorrect rendering.
+DAWN_NATIVE_EXPORT void WaitForCommandsToBeScheduled(WGPUDevice device);
+
+}  // namespace dawn::native::metal
+
+#pragma clang diagnostic pop
+
+#endif  // INCLUDE_DAWN_NATIVE_METALBACKEND_H_

vendor/zgpu/libs/dawn/include/dawn/native/NullBackend.h

@@ -0,0 +1,26 @@
+// Copyright 2018 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_NULLBACKEND_H_
+#define INCLUDE_DAWN_NATIVE_NULLBACKEND_H_
+
+#include "dawn/native/DawnNative.h"
+
+namespace dawn::native::null {
+
+// Nothing for now \o/
+
+}  // namespace dawn::native::null
+
+#endif  // INCLUDE_DAWN_NATIVE_NULLBACKEND_H_

vendor/zgpu/libs/dawn/include/dawn/native/OpenGLBackend.h

@@ -0,0 +1,59 @@
+// Copyright 2018 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_OPENGLBACKEND_H_
+#define INCLUDE_DAWN_NATIVE_OPENGLBACKEND_H_
+
+typedef void* EGLImage;
+
+#include "dawn/native/DawnNative.h"
+#include "dawn/webgpu_cpp_chained_struct.h"
+
+namespace dawn::native::opengl {
+
+// Can be chained in WGPURequestAdapterOptions
+struct DAWN_NATIVE_EXPORT RequestAdapterOptionsGetGLProc : wgpu::ChainedStruct {
+    RequestAdapterOptionsGetGLProc();
+
+    void* (*getProc)(const char*);
+};
+
+struct DAWN_NATIVE_EXPORT PhysicalDeviceDiscoveryOptions
+    : public PhysicalDeviceDiscoveryOptionsBase {
+    explicit PhysicalDeviceDiscoveryOptions(WGPUBackendType type);
+
+    void* (*getProc)(const char*);
+};
+
+// TODO(dawn:1774): Deprecated.
+using AdapterDiscoveryOptions = PhysicalDeviceDiscoveryOptions;
+
+// TODO(crbug.com/dawn/810): This struct can be removed once Chrome is no longer using it.
+struct DAWN_NATIVE_EXPORT AdapterDiscoveryOptionsES : public PhysicalDeviceDiscoveryOptions {
+    AdapterDiscoveryOptionsES();
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptorEGLImage : ExternalImageDescriptor {
+  public:
+    ExternalImageDescriptorEGLImage();
+
+    ::EGLImage image;
+};
+
+DAWN_NATIVE_EXPORT WGPUTexture
+WrapExternalEGLImage(WGPUDevice device, const ExternalImageDescriptorEGLImage* descriptor);
+
+}  // namespace dawn::native::opengl
+
+#endif  // INCLUDE_DAWN_NATIVE_OPENGLBACKEND_H_

vendor/zgpu/libs/dawn/include/dawn/native/VulkanBackend.h

@@ -0,0 +1,180 @@
+// Copyright 2018 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_VULKANBACKEND_H_
+#define INCLUDE_DAWN_NATIVE_VULKANBACKEND_H_
+
+#include <vulkan/vulkan.h>
+
+#include <array>
+#include <vector>
+
+#include "dawn/native/DawnNative.h"
+
+namespace dawn::native::vulkan {
+
+DAWN_NATIVE_EXPORT VkInstance GetInstance(WGPUDevice device);
+
+DAWN_NATIVE_EXPORT PFN_vkVoidFunction GetInstanceProcAddr(WGPUDevice device, const char* pName);
+
+struct DAWN_NATIVE_EXPORT PhysicalDeviceDiscoveryOptions
+    : public PhysicalDeviceDiscoveryOptionsBase {
+    PhysicalDeviceDiscoveryOptions();
+
+    bool forceSwiftShader = false;
+};
+
+// TODO(dawn:1774): Deprecated.
+using AdapterDiscoveryOptions = PhysicalDeviceDiscoveryOptions;
+
+enum class NeedsDedicatedAllocation {
+    Yes,
+    No,
+    // Use Vulkan reflection to detect whether a dedicated allocation is needed.
+    Detect,
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptorVk : ExternalImageDescriptor {
+  public:
+    // The following members may be ignored if |ExternalImageDescriptor::isInitialized| is false
+    // since the import does not need to preserve texture contents.
+
+    // See https://www.khronos.org/registry/vulkan/specs/1.1/html/chap7.html. The acquire
+    // operation old/new layouts must match exactly the layouts in the release operation. So
+    // we may need to issue two barriers releasedOldLayout -> releasedNewLayout ->
+    // cTextureDescriptor.usage if the new layout is not compatible with the desired usage.
+    // The first barrier is the queue transfer, the second is the layout transition to our
+    // desired usage.
+    VkImageLayout releasedOldLayout = VK_IMAGE_LAYOUT_GENERAL;
+    VkImageLayout releasedNewLayout = VK_IMAGE_LAYOUT_GENERAL;
+
+    // Try to detect the need to use a dedicated allocation for imported images by default but let
+    // the application override this as drivers have bugs and forget to require a dedicated
+    // allocation.
+    NeedsDedicatedAllocation dedicatedAllocation = NeedsDedicatedAllocation::Detect;
+
+  protected:
+    using ExternalImageDescriptor::ExternalImageDescriptor;
+};
+
+struct ExternalImageExportInfoVk : ExternalImageExportInfo {
+  public:
+    // See comments in |ExternalImageDescriptorVk|
+    // Contains the old/new layouts used in the queue release operation.
+    VkImageLayout releasedOldLayout;
+    VkImageLayout releasedNewLayout;
+
+  protected:
+    using ExternalImageExportInfo::ExternalImageExportInfo;
+};
+
+// Can't use DAWN_PLATFORM_IS(LINUX) since header included in both Dawn and Chrome
+#ifdef __linux__
+
+// Common properties of external images represented by FDs. On successful import the file
+// descriptor's ownership is transferred to the Dawn implementation and they shouldn't be
+// used outside of Dawn again. TODO(enga): Also transfer ownership in the error case so the
+// caller can assume the FD is always consumed.
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptorFD : ExternalImageDescriptorVk {
+  public:
+    int memoryFD;              // A file descriptor from an export of the memory of the image
+    std::vector<int> waitFDs;  // File descriptors of semaphores which will be waited on
+
+  protected:
+    using ExternalImageDescriptorVk::ExternalImageDescriptorVk;
+};
+
+// Descriptor for opaque file descriptor image import
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptorOpaqueFD : ExternalImageDescriptorFD {
+    ExternalImageDescriptorOpaqueFD();
+
+    VkDeviceSize allocationSize;  // Must match VkMemoryAllocateInfo from image creation
+    uint32_t memoryTypeIndex;     // Must match VkMemoryAllocateInfo from image creation
+};
+
+// The plane-wise offset and stride.
+struct DAWN_NATIVE_EXPORT PlaneLayout {
+    uint64_t offset;
+    uint32_t stride;
+};
+
+// Descriptor for dma-buf file descriptor image import
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptorDmaBuf : ExternalImageDescriptorFD {
+    ExternalImageDescriptorDmaBuf();
+
+    static constexpr uint32_t kMaxPlanes = 3;
+    std::array<PlaneLayout, kMaxPlanes> planeLayouts;
+    uint64_t drmModifier;  // DRM modifier of the buffer
+};
+
+// Info struct that is written to in |ExportVulkanImage|.
+struct DAWN_NATIVE_EXPORT ExternalImageExportInfoFD : ExternalImageExportInfoVk {
+  public:
+    // Contains the exported semaphore handles.
+    std::vector<int> semaphoreHandles;
+
+  protected:
+    using ExternalImageExportInfoVk::ExternalImageExportInfoVk;
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageExportInfoOpaqueFD : ExternalImageExportInfoFD {
+    ExternalImageExportInfoOpaqueFD();
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageExportInfoDmaBuf : ExternalImageExportInfoFD {
+    ExternalImageExportInfoDmaBuf();
+};
+
+#ifdef __ANDROID__
+
+// Descriptor for AHardwareBuffer image import
+struct DAWN_NATIVE_EXPORT ExternalImageDescriptorAHardwareBuffer : ExternalImageDescriptorVk {
+  public:
+    ExternalImageDescriptorAHardwareBuffer();
+
+    struct AHardwareBuffer* handle;  // The AHardwareBuffer which contains the memory of the image
+    std::vector<int> waitFDs;        // File descriptors of semaphores which will be waited on
+
+  protected:
+    using ExternalImageDescriptorVk::ExternalImageDescriptorVk;
+};
+
+struct DAWN_NATIVE_EXPORT ExternalImageExportInfoAHardwareBuffer : ExternalImageExportInfoFD {
+    ExternalImageExportInfoAHardwareBuffer();
+};
+
+#endif  // __ANDROID__
+
+#endif  // __linux__
+
+// Imports external memory into a Vulkan image. Internally, this uses external memory /
+// semaphore extensions to import the image and wait on the provided synchronizaton
+// primitives before the texture can be used.
+// On failure, returns a nullptr.
+DAWN_NATIVE_EXPORT WGPUTexture WrapVulkanImage(WGPUDevice device,
+                                               const ExternalImageDescriptorVk* descriptor);
+
+// Exports external memory from a Vulkan image. This must be called on wrapped textures
+// before they are destroyed. It writes the semaphore to wait on and the old/new image
+// layouts to |info|. Pass VK_IMAGE_LAYOUT_UNDEFINED as |desiredLayout| if you don't want to
+// perform a layout transition.
+DAWN_NATIVE_EXPORT bool ExportVulkanImage(WGPUTexture texture,
+                                          VkImageLayout desiredLayout,
+                                          ExternalImageExportInfoVk* info);
+// |ExportVulkanImage| with default desiredLayout of VK_IMAGE_LAYOUT_UNDEFINED.
+DAWN_NATIVE_EXPORT bool ExportVulkanImage(WGPUTexture texture, ExternalImageExportInfoVk* info);
+
+}  // namespace dawn::native::vulkan
+
+#endif  // INCLUDE_DAWN_NATIVE_VULKANBACKEND_H_

vendor/zgpu/libs/dawn/include/dawn/native/dawn_native_export.h

@@ -0,0 +1,36 @@
+// Copyright 2018 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_NATIVE_DAWN_NATIVE_EXPORT_H_
+#define INCLUDE_DAWN_NATIVE_DAWN_NATIVE_EXPORT_H_
+
+#if defined(DAWN_NATIVE_SHARED_LIBRARY)
+#if defined(_WIN32)
+#if defined(DAWN_NATIVE_IMPLEMENTATION)
+#define DAWN_NATIVE_EXPORT __declspec(dllexport)
+#else
+#define DAWN_NATIVE_EXPORT __declspec(dllimport)
+#endif
+#else  // defined(_WIN32)
+#if defined(DAWN_NATIVE_IMPLEMENTATION)
+#define DAWN_NATIVE_EXPORT __attribute__((visibility("default")))
+#else
+#define DAWN_NATIVE_EXPORT
+#endif
+#endif  // defined(_WIN32)
+#else   // defined(DAWN_NATIVE_SHARED_LIBRARY)
+#define DAWN_NATIVE_EXPORT
+#endif  // defined(DAWN_NATIVE_SHARED_LIBRARY)
+
+#endif  // INCLUDE_DAWN_NATIVE_DAWN_NATIVE_EXPORT_H_

vendor/zgpu/libs/dawn/include/dawn/platform/DawnPlatform.h

@@ -0,0 +1,128 @@
+// Copyright 2019 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_PLATFORM_DAWNPLATFORM_H_
+#define INCLUDE_DAWN_PLATFORM_DAWNPLATFORM_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+#include "dawn/platform/dawn_platform_export.h"
+#include "dawn/webgpu.h"
+
+namespace dawn::platform {
+
+enum class TraceCategory {
+    General,     // General trace events
+    Validation,  // Dawn validation
+    Recording,   // Native command recording
+    GPUWork,     // Actual GPU work
+};
+
+class DAWN_PLATFORM_EXPORT CachingInterface {
+  public:
+    CachingInterface();
+    virtual ~CachingInterface();
+
+    // LoadData has two modes. The first mode is used to get a value which
+    // corresponds to the |key|. The |valueOut| is a caller provided buffer
+    // allocated to the size |valueSize| which is loaded with data of the
+    // size returned. The second mode is used to query for the existence of
+    // the |key| where |valueOut| is nullptr and |valueSize| must be 0.
+    // The return size is non-zero if the |key| exists.
+    virtual size_t LoadData(const void* key, size_t keySize, void* valueOut, size_t valueSize) = 0;
+
+    // StoreData puts a |value| in the cache which corresponds to the |key|.
+    virtual void StoreData(const void* key,
+                           size_t keySize,
+                           const void* value,
+                           size_t valueSize) = 0;
+
+  private:
+    CachingInterface(const CachingInterface&) = delete;
+    CachingInterface& operator=(const CachingInterface&) = delete;
+};
+
+class DAWN_PLATFORM_EXPORT WaitableEvent {
+  public:
+    WaitableEvent() = default;
+    virtual ~WaitableEvent() = default;
+    virtual void Wait() = 0;        // Wait for completion
+    virtual bool IsComplete() = 0;  // Non-blocking check if the event is complete
+};
+
+using PostWorkerTaskCallback = void (*)(void* userdata);
+
+class DAWN_PLATFORM_EXPORT WorkerTaskPool {
+  public:
+    WorkerTaskPool() = default;
+    virtual ~WorkerTaskPool() = default;
+    virtual std::unique_ptr<WaitableEvent> PostWorkerTask(PostWorkerTaskCallback,
+                                                          void* userdata) = 0;
+};
+
+class DAWN_PLATFORM_EXPORT Platform {
+  public:
+    Platform();
+    virtual ~Platform();
+
+    virtual const unsigned char* GetTraceCategoryEnabledFlag(TraceCategory category);
+
+    virtual double MonotonicallyIncreasingTime();
+
+    virtual uint64_t AddTraceEvent(char phase,
+                                   const unsigned char* categoryGroupEnabled,
+                                   const char* name,
+                                   uint64_t id,
+                                   double timestamp,
+                                   int numArgs,
+                                   const char** argNames,
+                                   const unsigned char* argTypes,
+                                   const uint64_t* argValues,
+                                   unsigned char flags);
+
+    // Invoked to add a UMA histogram count-based sample
+    virtual void HistogramCustomCounts(const char* name,
+                                       int sample,
+                                       int min,
+                                       int max,
+                                       int bucketCount);
+
+    // Invoked to add a UMA histogram enumeration sample
+    virtual void HistogramEnumeration(const char* name, int sample, int boundaryValue);
+
+    // Invoked to add a UMA histogram sparse sample
+    virtual void HistogramSparse(const char* name, int sample);
+
+    // Invoked to add a UMA histogram boolean sample
+    virtual void HistogramBoolean(const char* name, bool sample);
+
+    // The returned CachingInterface is expected to outlive the device which uses it to persistently
+    // cache objects.
+    virtual CachingInterface* GetCachingInterface();
+
+    virtual std::unique_ptr<WorkerTaskPool> CreateWorkerTaskPool();
+
+  private:
+    Platform(const Platform&) = delete;
+    Platform& operator=(const Platform&) = delete;
+};
+
+}  // namespace dawn::platform
+
+// TODO(dawn:824): Remove once the deprecation period is passed.
+namespace dawn_platform = dawn::platform;
+
+#endif  // INCLUDE_DAWN_PLATFORM_DAWNPLATFORM_H_

vendor/zgpu/libs/dawn/include/dawn/platform/dawn_platform_export.h

@@ -0,0 +1,36 @@
+// Copyright 2020 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_PLATFORM_DAWN_PLATFORM_EXPORT_H_
+#define INCLUDE_DAWN_PLATFORM_DAWN_PLATFORM_EXPORT_H_
+
+#if defined(DAWN_PLATFORM_SHARED_LIBRARY)
+#if defined(_WIN32)
+#if defined(DAWN_PLATFORM_IMPLEMENTATION)
+#define DAWN_PLATFORM_EXPORT __declspec(dllexport)
+#else
+#define DAWN_PLATFORM_EXPORT __declspec(dllimport)
+#endif
+#else  // defined(_WIN32)
+#if defined(DAWN_PLATFORM_IMPLEMENTATION)
+#define DAWN_PLATFORM_EXPORT __attribute__((visibility("default")))
+#else
+#define DAWN_PLATFORM_EXPORT
+#endif
+#endif  // defined(_WIN32)
+#else   // defined(DAWN_PLATFORM_SHARED_LIBRARY)
+#define DAWN_PLATFORM_EXPORT
+#endif  // defined(DAWN_PLATFORM_SHARED_LIBRARY)
+
+#endif  // INCLUDE_DAWN_PLATFORM_DAWN_PLATFORM_EXPORT_H_

vendor/zgpu/libs/dawn/include/dawn/webgpu_cpp_chained_struct.h

@@ -0,0 +1,35 @@
+#ifdef __EMSCRIPTEN__
+#error "Do not include this header. Emscripten already provides headers needed for WebGPU."
+#endif
+#ifndef WEBGPU_CPP_CHAINED_STRUCT_H_
+#define WEBGPU_CPP_CHAINED_STRUCT_H_
+
+#include <cstddef>
+#include <cstdint>
+
+// This header file declares the ChainedStruct structures separately from the WebGPU
+// headers so that dependencies can directly extend structures without including the larger header
+// which exposes capabilities that may require correctly set proc tables.
+namespace wgpu {
+
+    namespace detail {
+        constexpr size_t ConstexprMax(size_t a, size_t b) {
+            return a > b ? a : b;
+        }
+    }  // namespace detail
+
+    enum class SType : uint32_t;
+
+    struct ChainedStruct {
+        ChainedStruct const * nextInChain = nullptr;
+        SType sType = SType(0u);
+    };
+
+    struct ChainedStructOut {
+        ChainedStructOut * nextInChain = nullptr;
+        SType sType = SType(0u);
+    };
+
+}  // namespace wgpu}
+
+#endif // WEBGPU_CPP_CHAINED_STRUCT_H_

vendor/zgpu/libs/dawn/include/dawn/wire/Wire.h

@@ -0,0 +1,58 @@
+// Copyright 2017 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_WIRE_WIRE_H_
+#define INCLUDE_DAWN_WIRE_WIRE_H_
+
+#include <cstdint>
+#include <limits>
+
+#include "dawn/webgpu.h"
+#include "dawn/wire/dawn_wire_export.h"
+
+namespace dawn::wire {
+
+class DAWN_WIRE_EXPORT CommandSerializer {
+  public:
+    CommandSerializer();
+    virtual ~CommandSerializer();
+    CommandSerializer(const CommandSerializer& rhs) = delete;
+    CommandSerializer& operator=(const CommandSerializer& rhs) = delete;
+
+    // Get space for serializing commands.
+    // GetCmdSpace will never be called with a value larger than
+    // what GetMaximumAllocationSize returns. Return nullptr to indicate
+    // a fatal error.
+    virtual void* GetCmdSpace(size_t size) = 0;
+    virtual bool Flush() = 0;
+    virtual size_t GetMaximumAllocationSize() const = 0;
+    virtual void OnSerializeError();
+};
+
+class DAWN_WIRE_EXPORT CommandHandler {
+  public:
+    CommandHandler();
+    virtual ~CommandHandler();
+    CommandHandler(const CommandHandler& rhs) = delete;
+    CommandHandler& operator=(const CommandHandler& rhs) = delete;
+
+    virtual const volatile char* HandleCommands(const volatile char* commands, size_t size) = 0;
+};
+
+}  // namespace dawn::wire
+
+// TODO(dawn:824): Remove once the deprecation period is passed.
+namespace dawn_wire = dawn::wire;
+
+#endif  // INCLUDE_DAWN_WIRE_WIRE_H_

vendor/zgpu/libs/dawn/include/dawn/wire/WireClient.h

@@ -0,0 +1,181 @@
+// Copyright 2019 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_WIRE_WIRECLIENT_H_
+#define INCLUDE_DAWN_WIRE_WIRECLIENT_H_
+
+#include <memory>
+#include <vector>
+
+#include "dawn/dawn_proc_table.h"
+#include "dawn/wire/Wire.h"
+
+namespace dawn::wire {
+
+namespace client {
+class Client;
+class MemoryTransferService;
+
+DAWN_WIRE_EXPORT const DawnProcTable& GetProcs();
+}  // namespace client
+
+struct ReservedTexture {
+    WGPUTexture texture;
+    uint32_t id;
+    uint32_t generation;
+    uint32_t deviceId;
+    uint32_t deviceGeneration;
+};
+
+struct ReservedSwapChain {
+    WGPUSwapChain swapchain;
+    uint32_t id;
+    uint32_t generation;
+    uint32_t deviceId;
+    uint32_t deviceGeneration;
+};
+
+struct ReservedDevice {
+    WGPUDevice device;
+    uint32_t id;
+    uint32_t generation;
+};
+
+struct ReservedInstance {
+    WGPUInstance instance;
+    uint32_t id;
+    uint32_t generation;
+};
+
+struct DAWN_WIRE_EXPORT WireClientDescriptor {
+    CommandSerializer* serializer;
+    client::MemoryTransferService* memoryTransferService = nullptr;
+};
+
+class DAWN_WIRE_EXPORT WireClient : public CommandHandler {
+  public:
+    explicit WireClient(const WireClientDescriptor& descriptor);
+    ~WireClient() override;
+
+    const volatile char* HandleCommands(const volatile char* commands, size_t size) override;
+
+    ReservedTexture ReserveTexture(WGPUDevice device, const WGPUTextureDescriptor* descriptor);
+    ReservedSwapChain ReserveSwapChain(WGPUDevice device,
+                                       const WGPUSwapChainDescriptor* descriptor);
+    ReservedDevice ReserveDevice();
+    ReservedInstance ReserveInstance();
+
+    void ReclaimTextureReservation(const ReservedTexture& reservation);
+    void ReclaimSwapChainReservation(const ReservedSwapChain& reservation);
+    void ReclaimDeviceReservation(const ReservedDevice& reservation);
+    void ReclaimInstanceReservation(const ReservedInstance& reservation);
+
+    // Disconnects the client.
+    // Commands allocated after this point will not be sent.
+    void Disconnect();
+
+  private:
+    std::unique_ptr<client::Client> mImpl;
+};
+
+namespace client {
+class DAWN_WIRE_EXPORT MemoryTransferService {
+  public:
+    MemoryTransferService();
+    virtual ~MemoryTransferService();
+
+    class ReadHandle;
+    class WriteHandle;
+
+    // Create a handle for reading server data.
+    // This may fail and return nullptr.
+    virtual ReadHandle* CreateReadHandle(size_t) = 0;
+
+    // Create a handle for writing server data.
+    // This may fail and return nullptr.
+    virtual WriteHandle* CreateWriteHandle(size_t) = 0;
+
+    class DAWN_WIRE_EXPORT ReadHandle {
+      public:
+        ReadHandle();
+        virtual ~ReadHandle();
+
+        // Get the required serialization size for SerializeCreate
+        virtual size_t SerializeCreateSize() = 0;
+
+        // Serialize the handle into |serializePointer| so it can be received by the server.
+        virtual void SerializeCreate(void* serializePointer) = 0;
+
+        // Simply return the base address of the allocation (without applying any offset)
+        // Returns nullptr if the allocation failed.
+        // The data must live at least until the ReadHandle is destructued
+        virtual const void* GetData() = 0;
+
+        // Gets called when a MapReadCallback resolves.
+        // deserialize the data update and apply
+        // it to the range (offset, offset + size) of allocation
+        // There could be nothing to be deserialized (if using shared memory)
+        // Needs to check potential offset/size OOB and overflow
+        virtual bool DeserializeDataUpdate(const void* deserializePointer,
+                                           size_t deserializeSize,
+                                           size_t offset,
+                                           size_t size) = 0;
+
+      private:
+        ReadHandle(const ReadHandle&) = delete;
+        ReadHandle& operator=(const ReadHandle&) = delete;
+    };
+
+    class DAWN_WIRE_EXPORT WriteHandle {
+      public:
+        WriteHandle();
+        virtual ~WriteHandle();
+
+        // Get the required serialization size for SerializeCreate
+        virtual size_t SerializeCreateSize() = 0;
+
+        // Serialize the handle into |serializePointer| so it can be received by the server.
+        virtual void SerializeCreate(void* serializePointer) = 0;
+
+        // Simply return the base address of the allocation (without applying any offset)
+        // The data returned should be zero-initialized.
+        // The data returned must live at least until the WriteHandle is destructed.
+        // On failure, the pointer returned should be null.
+        virtual void* GetData() = 0;
+
+        // Get the required serialization size for SerializeDataUpdate
+        virtual size_t SizeOfSerializeDataUpdate(size_t offset, size_t size) = 0;
+
+        // Serialize a command to send the modified contents of
+        // the subrange (offset, offset + size) of the allocation at buffer unmap
+        // This subrange is always the whole mapped region for now
+        // There could be nothing to be serialized (if using shared memory)
+        virtual void SerializeDataUpdate(void* serializePointer, size_t offset, size_t size) = 0;
+
+      private:
+        WriteHandle(const WriteHandle&) = delete;
+        WriteHandle& operator=(const WriteHandle&) = delete;
+    };
+
+  private:
+    MemoryTransferService(const MemoryTransferService&) = delete;
+    MemoryTransferService& operator=(const MemoryTransferService&) = delete;
+};
+
+// Backdoor to get the order of the ProcMap for testing
+DAWN_WIRE_EXPORT std::vector<const char*> GetProcMapNamesForTesting();
+}  // namespace client
+}  // namespace dawn::wire
+
+#endif  // INCLUDE_DAWN_WIRE_WIRECLIENT_H_

vendor/zgpu/libs/dawn/include/dawn/wire/WireServer.h

@@ -0,0 +1,154 @@
+// Copyright 2019 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_WIRE_WIRESERVER_H_
+#define INCLUDE_DAWN_WIRE_WIRESERVER_H_
+
+#include <memory>
+
+#include "dawn/wire/Wire.h"
+
+struct DawnProcTable;
+
+namespace dawn::wire {
+
+namespace server {
+class Server;
+class MemoryTransferService;
+}  // namespace server
+
+struct DAWN_WIRE_EXPORT WireServerDescriptor {
+    const DawnProcTable* procs;
+    CommandSerializer* serializer;
+    server::MemoryTransferService* memoryTransferService = nullptr;
+};
+
+class DAWN_WIRE_EXPORT WireServer : public CommandHandler {
+  public:
+    explicit WireServer(const WireServerDescriptor& descriptor);
+    ~WireServer() override;
+
+    const volatile char* HandleCommands(const volatile char* commands, size_t size) override;
+
+    bool InjectTexture(WGPUTexture texture,
+                       uint32_t id,
+                       uint32_t generation,
+                       uint32_t deviceId,
+                       uint32_t deviceGeneration);
+    bool InjectSwapChain(WGPUSwapChain swapchain,
+                         uint32_t id,
+                         uint32_t generation,
+                         uint32_t deviceId,
+                         uint32_t deviceGeneration);
+
+    bool InjectDevice(WGPUDevice device, uint32_t id, uint32_t generation);
+
+    bool InjectInstance(WGPUInstance instance, uint32_t id, uint32_t generation);
+
+    // Look up a device by (id, generation) pair. Returns nullptr if the generation
+    // has expired or the id is not found.
+    // The Wire does not have destroy hooks to allow an embedder to observe when an object
+    // has been destroyed, but in Chrome, we need to know the list of live devices so we
+    // can call device.Tick() on all of them periodically to ensure progress on asynchronous
+    // work is made. Getting this list can be done by tracking the (id, generation) of
+    // previously injected devices, and observing if GetDevice(id, generation) returns non-null.
+    WGPUDevice GetDevice(uint32_t id, uint32_t generation);
+
+    // Check if a device handle is known by the wire.
+    // In Chrome, we need to know the list of live devices so we can call device.Tick() on all of
+    // them periodically to ensure progress on asynchronous work is made.
+    bool IsDeviceKnown(WGPUDevice device) const;
+
+  private:
+    std::unique_ptr<server::Server> mImpl;
+};
+
+namespace server {
+class DAWN_WIRE_EXPORT MemoryTransferService {
+  public:
+    MemoryTransferService();
+    virtual ~MemoryTransferService();
+
+    class ReadHandle;
+    class WriteHandle;
+
+    // Deserialize data to create Read/Write handles. These handles are for the client
+    // to Read/Write data.
+    virtual bool DeserializeReadHandle(const void* deserializePointer,
+                                       size_t deserializeSize,
+                                       ReadHandle** readHandle) = 0;
+    virtual bool DeserializeWriteHandle(const void* deserializePointer,
+                                        size_t deserializeSize,
+                                        WriteHandle** writeHandle) = 0;
+
+    class DAWN_WIRE_EXPORT ReadHandle {
+      public:
+        ReadHandle();
+        virtual ~ReadHandle();
+
+        // Return the size of the command serialized if
+        // SerializeDataUpdate is called with the same offset/size args
+        virtual size_t SizeOfSerializeDataUpdate(size_t offset, size_t size) = 0;
+
+        // Gets called when a MapReadCallback resolves.
+        // Serialize the data update for the range (offset, offset + size) into
+        // |serializePointer| to the client There could be nothing to be serialized (if
+        // using shared memory)
+        virtual void SerializeDataUpdate(const void* data,
+                                         size_t offset,
+                                         size_t size,
+                                         void* serializePointer) = 0;
+
+      private:
+        ReadHandle(const ReadHandle&) = delete;
+        ReadHandle& operator=(const ReadHandle&) = delete;
+    };
+
+    class DAWN_WIRE_EXPORT WriteHandle {
+      public:
+        WriteHandle();
+        virtual ~WriteHandle();
+
+        // Set the target for writes from the client. DeserializeFlush should copy data
+        // into the target.
+        void SetTarget(void* data);
+        // Set Staging data length for OOB check
+        void SetDataLength(size_t dataLength);
+
+        // This function takes in the serialized result of
+        // client::MemoryTransferService::WriteHandle::SerializeDataUpdate.
+        // Needs to check potential offset/size OOB and overflow
+        virtual bool DeserializeDataUpdate(const void* deserializePointer,
+                                           size_t deserializeSize,
+                                           size_t offset,
+                                           size_t size) = 0;
+
+      protected:
+        void* mTargetData = nullptr;
+        size_t mDataLength = 0;
+
+      private:
+        WriteHandle(const WriteHandle&) = delete;
+        WriteHandle& operator=(const WriteHandle&) = delete;
+    };
+
+  private:
+    MemoryTransferService(const MemoryTransferService&) = delete;
+    MemoryTransferService& operator=(const MemoryTransferService&) = delete;
+};
+}  // namespace server
+
+}  // namespace dawn::wire
+
+#endif  // INCLUDE_DAWN_WIRE_WIRESERVER_H_

vendor/zgpu/libs/dawn/include/dawn/wire/dawn_wire_export.h

@@ -0,0 +1,36 @@
+// Copyright 2018 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_DAWN_WIRE_DAWN_WIRE_EXPORT_H_
+#define INCLUDE_DAWN_WIRE_DAWN_WIRE_EXPORT_H_
+
+#if defined(DAWN_WIRE_SHARED_LIBRARY)
+#if defined(_WIN32)
+#if defined(DAWN_WIRE_IMPLEMENTATION)
+#define DAWN_WIRE_EXPORT __declspec(dllexport)
+#else
+#define DAWN_WIRE_EXPORT __declspec(dllimport)
+#endif
+#else  // defined(_WIN32)
+#if defined(DAWN_WIRE_IMPLEMENTATION)
+#define DAWN_WIRE_EXPORT __attribute__((visibility("default")))
+#else
+#define DAWN_WIRE_EXPORT
+#endif
+#endif  // defined(_WIN32)
+#else   // defined(DAWN_WIRE_SHARED_LIBRARY)
+#define DAWN_WIRE_EXPORT
+#endif  // defined(DAWN_WIRE_SHARED_LIBRARY)
+
+#endif  // INCLUDE_DAWN_WIRE_DAWN_WIRE_EXPORT_H_

vendor/zgpu/libs/dawn/include/tint/override_id.h

@@ -0,0 +1,66 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_OVERRIDE_ID_H_
+#define SRC_TINT_OVERRIDE_ID_H_
+
+#include <stdint.h>
+#include <functional>
+
+#include "src/tint/reflection.h"
+
+namespace tint {
+
+/// OverrideId is a numerical identifier for an override variable, unique per program.
+struct OverrideId {
+    uint16_t value = 0;
+
+    /// Reflect the fields of this struct so that it can be used by tint::ForeachField()
+    TINT_REFLECT(value);
+};
+
+/// Equality operator for OverrideId
+/// @param lhs the OverrideId on the left of the '=' operator
+/// @param rhs the OverrideId on the right of the '=' operator
+/// @returns true if `lhs` is equal to `rhs`
+inline bool operator==(OverrideId lhs, OverrideId rhs) {
+    return lhs.value == rhs.value;
+}
+
+/// Less-than operator for OverrideId
+/// @param lhs the OverrideId on the left of the '<' operator
+/// @param rhs the OverrideId on the right of the '<' operator
+/// @returns true if `lhs` comes before `rhs`
+inline bool operator<(OverrideId lhs, OverrideId rhs) {
+    return lhs.value < rhs.value;
+}
+
+}  // namespace tint
+
+namespace std {
+
+/// Custom std::hash specialization for tint::OverrideId.
+template <>
+class hash<tint::OverrideId> {
+  public:
+    /// @param id the override identifier
+    /// @return the hash of the override identifier
+    inline std::size_t operator()(tint::OverrideId id) const {
+        return std::hash<decltype(tint::OverrideId::value)>()(id.value);
+    }
+};
+
+}  // namespace std
+
+#endif  // SRC_TINT_OVERRIDE_ID_H_

vendor/zgpu/libs/dawn/include/tint/tint.h

@@ -0,0 +1,82 @@
+// Copyright 2020 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_TINT_TINT_H_
+#define INCLUDE_TINT_TINT_H_
+
+// Guard for accidental includes to private headers
+#define CURRENTLY_IN_TINT_PUBLIC_HEADER
+
+// TODO(tint:88): When implementing support for an install target, all of these
+//                headers will need to be moved to include/tint/.
+
+#include "src/tint/ast/transform/first_index_offset.h"
+#include "src/tint/ast/transform/renamer.h"
+#include "src/tint/ast/transform/single_entry_point.h"
+#include "src/tint/ast/transform/substitute_override.h"
+#include "src/tint/ast/transform/vertex_pulling.h"
+#include "src/tint/diagnostic/printer.h"
+#include "src/tint/inspector/inspector.h"
+#include "src/tint/reader/reader.h"
+#include "src/tint/transform/manager.h"
+#include "src/tint/type/manager.h"
+#include "src/tint/utils/unicode.h"
+#include "src/tint/writer/array_length_from_uniform_options.h"
+#include "src/tint/writer/binding_point.h"
+#include "src/tint/writer/binding_remapper_options.h"
+#include "src/tint/writer/external_texture_options.h"
+#include "src/tint/writer/flatten_bindings.h"
+#include "src/tint/writer/writer.h"
+
+#if TINT_BUILD_SPV_READER
+#include "src/tint/reader/spirv/parser.h"
+#endif  // TINT_BUILD_SPV_READER
+
+#if TINT_BUILD_WGSL_READER
+#include "src/tint/reader/wgsl/parser.h"
+#endif  // TINT_BUILD_WGSL_READER
+
+#if TINT_BUILD_SPV_WRITER
+#include "src/tint/writer/spirv/generator.h"
+#endif  // TINT_BUILD_SPV_WRITER
+
+#if TINT_BUILD_WGSL_WRITER
+#include "src/tint/writer/wgsl/generator.h"
+#endif  // TINT_BUILD_WGSL_WRITER
+
+#if TINT_BUILD_MSL_WRITER
+#include "src/tint/writer/msl/generator.h"
+#endif  // TINT_BUILD_MSL_WRITER
+
+#if TINT_BUILD_HLSL_WRITER
+#include "src/tint/writer/hlsl/generator.h"
+#endif  // TINT_BUILD_HLSL_WRITER
+
+#if TINT_BUILD_GLSL_WRITER
+#include "src/tint/writer/glsl/generator.h"
+#endif  // TINT_BUILD_GLSL_WRITER
+
+namespace tint {
+
+/// Initialize initializes the Tint library. Call before using the Tint API.
+void Initialize();
+
+/// Shutdown uninitializes the Tint library. Call after using the Tint API.
+void Shutdown();
+
+}  // namespace tint
+
+#undef CURRENTLY_IN_TINT_PUBLIC_HEADER
+
+#endif  // INCLUDE_TINT_TINT_H_

vendor/zgpu/libs/dawn/include/webgpu/webgpu.h

@@ -0,0 +1,20 @@
+// Copyright 2022 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_WEBGPU_WEBGPU_H_
+#define INCLUDE_WEBGPU_WEBGPU_H_
+
+#include "dawn/webgpu.h"
+
+#endif  // INCLUDE_WEBGPU_WEBGPU_H_

vendor/zgpu/libs/dawn/include/webgpu/webgpu_cpp.h

@@ -0,0 +1,20 @@
+// Copyright 2022 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_WEBGPU_WEBGPU_CPP_H_
+#define INCLUDE_WEBGPU_WEBGPU_CPP_H_
+
+#include "dawn/webgpu_cpp.h"
+
+#endif  // INCLUDE_WEBGPU_WEBGPU_CPP_H_

vendor/zgpu/libs/dawn/include/webgpu/webgpu_glfw.h

@@ -0,0 +1,58 @@
+// Copyright 2022 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef INCLUDE_WEBGPU_WEBGPU_GLFW_H_
+#define INCLUDE_WEBGPU_WEBGPU_GLFW_H_
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#if defined(WGPU_GLFW_SHARED_LIBRARY)
+#if defined(_WIN32)
+#if defined(WGPU_GLFW_IMPLEMENTATION)
+#define WGPU_GLFW_EXPORT __declspec(dllexport)
+#else
+#define WGPU_GLFW_EXPORT __declspec(dllimport)
+#endif
+#else  // defined(_WIN32)
+#if defined(WGPU_GLFW_IMPLEMENTATION)
+#define WGPU_GLFW_EXPORT __attribute__((visibility("default")))
+#else
+#define WGPU_GLFW_EXPORT
+#endif
+#endif  // defined(_WIN32)
+#else   // defined(WGPU_GLFW_SHARED_LIBRARY)
+#define WGPU_GLFW_EXPORT
+#endif  // defined(WGPU_GLFW_SHARED_LIBRARY)
+
+struct GLFWwindow;
+
+namespace wgpu::glfw {
+
+// Does the necessary setup on the GLFWwindow to allow creating a wgpu::Surface with it and
+// calls `instance.CreateSurface` with the correct descriptor for this window.
+// Returns a null wgpu::Surface on failure.
+WGPU_GLFW_EXPORT wgpu::Surface CreateSurfaceForWindow(const wgpu::Instance& instance,
+                                                      GLFWwindow* window);
+
+// Use for testing only. Does everything that CreateSurfaceForWindow does except the call to
+// CreateSurface. Useful to be able to modify the descriptor for testing, or when trying to
+// avoid using the global proc table.
+WGPU_GLFW_EXPORT std::unique_ptr<wgpu::ChainedStruct> SetupWindowAndGetSurfaceDescriptor(
+    GLFWwindow* window);
+
+}  // namespace wgpu::glfw
+
+#endif  // INCLUDE_WEBGPU_WEBGPU_GLFW_H_