dawn.patch

diff --git a/include/webgpu/webgpu_sdl.h b/include/webgpu/webgpu_sdl.h
new file mode 100644
index 00000000..6e2eaaa5
--- /dev/null
+++ b/include/webgpu/webgpu_sdl.h
@@ -0,0 +1,59 @@
+// Copyright 2022 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.
+
+#ifndef INCLUDE_WEBGPU_WEBGPU_SDL_H_
+#define INCLUDE_WEBGPU_WEBGPU_SDL_H_
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#if defined(WGPU_SDL_SHARED_LIBRARY)
+#if defined(_WIN32)
+#if defined(WGPU_SDL_IMPLEMENTATION)
+#define WGPU_SDL_EXPORT __declspec(dllexport)
+#else
+#define WGPU_SDL_EXPORT __declspec(dllimport)
+#endif
+#else  // defined(_WIN32)
+#if defined(WGPU_SDL_IMPLEMENTATION)
+#define WGPU_SDL_EXPORT __attribute__((visibility("default")))
+#else
+#define WGPU_SDL_EXPORT
+#endif
+#endif  // defined(_WIN32)
+#else   // defined(WGPU_SDL_SHARED_LIBRARY)
+#define WGPU_SDL_EXPORT
+#endif  // defined(WGPU_SDL_SHARED_LIBRARY)
+
+namespace wgpu::sdl {
+
+WGPU_SDL_EXPORT WGPUSurface CreateSurfaceForWindow(DawnProcTable &procs, const WGPUInstance& instance, void* nativeData);
+
+}  // namespace wgpu::sdl
+
+#endif  // INCLUDE_WEBGPU_WEBGPU_SDL_H_
diff --git a/src/dawn/CMakeLists.txt b/src/dawn/CMakeLists.txt
index f4e194d9..2d18d091 100644
--- a/src/dawn/CMakeLists.txt
+++ b/src/dawn/CMakeLists.txt
@@ -36,6 +36,7 @@ add_subdirectory(wire)
 # TODO(dawn:269): Remove once the implementation-based swapchains are removed.
 add_subdirectory(utils)
 add_subdirectory(glfw)
+add_subdirectory(sdl)
 add_subdirectory(tests/benchmarks)
 
 if (DAWN_BUILD_SAMPLES)
diff --git a/src/dawn/native/d3d/SwapChainD3D.cpp b/src/dawn/native/d3d/SwapChainD3D.cpp
index 57b85028..3e00b807 100644
--- a/src/dawn/native/d3d/SwapChainD3D.cpp
+++ b/src/dawn/native/d3d/SwapChainD3D.cpp
@@ -198,11 +198,13 @@ MaybeError SwapChain::InitializeSwapChainFromScratch() {
     ComPtr<IDXGISwapChain1> swapChain1;
     switch (GetSurface()->GetType()) {
         case Surface::Type::WindowsHWND: {
+            fprintf(stderr, "CreateSwapChainForHwnd 1\n");
             DAWN_TRY(CheckHRESULT(
                 factory2->CreateSwapChainForHwnd(GetD3DDeviceForCreatingSwapChain(),
                                                  static_cast<HWND>(GetSurface()->GetHWND()),
                                                  &swapChainDesc, nullptr, nullptr, &swapChain1),
                 "Creating the IDXGISwapChain1"));
+            fprintf(stderr, "CreateSwapChainForHwnd 2\n");
             break;
         }
         case Surface::Type::WindowsCoreWindow: {
diff --git a/src/dawn/node/CMakeLists.txt b/src/dawn/node/CMakeLists.txt
index e0fe9b77..2342910c 100644
--- a/src/dawn/node/CMakeLists.txt
+++ b/src/dawn/node/CMakeLists.txt
@@ -85,7 +85,7 @@ set_target_properties(dawn_node PROPERTIES
     CXX_STANDARD 17
 )
 target_link_libraries(dawn_node dawn_node_binding dawn_node_interop dawn_native dawncpp dawn_proc
-                      libtint)
+                      libtint dawn_sdl)
 target_include_directories(dawn_node PRIVATE
     "${PROJECT_SOURCE_DIR}"
     "${NODE_ADDON_API_DIR}"
diff --git a/src/dawn/node/Module.cpp b/src/dawn/node/Module.cpp
index 1061c8b6..918851ab 100644
--- a/src/dawn/node/Module.cpp
+++ b/src/dawn/node/Module.cpp
@@ -34,8 +34,14 @@
 #include "dawn/dawn_proc.h"
 #include "src/dawn/node/binding/Flags.h"
 #include "src/dawn/node/binding/GPU.h"
+#include "src/dawn/node/binding/GPUDevice.h"
+#include "src/dawn/node/binding/GPUTexture.h"
+#include "src/dawn/node/binding/GPUTextureView.h"
+#include "src/dawn/common/Platform.h"
 #include "tint/tint.h"
 
+#include "webgpu/webgpu_sdl.h"
+
 #ifdef DAWN_EMIT_COVERAGE
 extern "C" {
 void __llvm_profile_reset_counters(void);
@@ -46,8 +52,10 @@ int __llvm_profile_write_file(void);
 
 namespace {
 
+DawnProcTable procs;
+
 Napi::Value CreateGPU(const Napi::CallbackInfo& info) {
-    const auto& env = info.Env();
+    const Napi::Env& env = info.Env();
 
     std::tuple<std::vector<std::string>> args;
     auto res = wgpu::interop::FromJS(info, args);
@@ -73,6 +81,138 @@ Napi::Value CreateGPU(const Napi::CallbackInfo& info) {
     return wgpu::interop::GPU::Create<wgpu::binding::GPU>(env, std::move(flags));
 }
 
+class Renderer : public Napi::ObjectWrap<Renderer> {
+
+    static Napi::FunctionReference constructor;
+
+public:
+
+    Napi::ObjectReference _window;
+    WGPUInstance _instance;
+    WGPUDevice _device;
+    WGPUSwapChain _swapChain;
+
+    static void Init(const Napi::Env &env) {
+        Napi::Function func = DefineClass(env, "Renderer", {
+            InstanceMethod("getPreferredFormat", &Renderer::getPreferredFormat),
+            InstanceMethod("getCurrentTexture", &Renderer::getCurrentTexture),
+            InstanceMethod("getCurrentTextureView", &Renderer::getCurrentTextureView),
+            InstanceMethod("swap", &Renderer::swap),
+            InstanceMethod("resize", &Renderer::resize),
+        });
+
+        constructor = Napi::Persistent(func);
+        constructor.SuppressDestruct();
+    }
+
+    Renderer(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Renderer>(info) {
+        const Napi::Env& env = info.Env();
+        auto jsDevice = info[0].As<Napi::Object>();
+        auto jsWindow = info[1].As<Napi::Object>();
+
+        _window = Napi::Persistent(jsWindow);
+        _instance = dawn::native::Instance().Get();
+        _device = (reinterpret_cast<wgpu::binding::GPUDevice*>(wgpu::interop::GPUDevice::Unwrap(jsDevice)))->device_.Get();
+        _createSwapChain(env);
+    };
+
+    static Napi::Object NewInstance(Napi::Env env, Napi::Value device, Napi::Value window) {
+        return constructor.New({ device, window});
+    }
+
+    Napi::Value getPreferredFormat(const Napi::CallbackInfo& info) {
+        const Napi::Env& env = info.Env();
+        return Napi::String::From(env, "bgra8unorm");
+    }
+
+    Napi::Value getCurrentTexture(const Napi::CallbackInfo& info) {
+        const Napi::Env& env = info.Env();
+        WGPUTexture texture = procs.swapChainGetCurrentTexture(_swapChain);
+        return wgpu::interop::GPUTexture::Create<wgpu::binding::GPUTexture>(env,
+            wgpu::Device::Acquire(_device),
+            wgpu::TextureDescriptor(),
+            wgpu::Texture::Acquire(texture)
+        );
+    }
+
+    Napi::Value getCurrentTextureView(const Napi::CallbackInfo& info) {
+        const Napi::Env& env = info.Env();
+        WGPUTextureView textureView = procs.swapChainGetCurrentTextureView(_swapChain);
+        return wgpu::interop::GPUTextureView::Create<wgpu::binding::GPUTextureView>(env,
+            wgpu::TextureViewDescriptor(),
+            wgpu::TextureView::Acquire(textureView)
+        );
+    }
+
+    Napi::Value swap(const Napi::CallbackInfo& info) {
+        const Napi::Env& env = info.Env();
+        procs.swapChainPresent(_swapChain);
+        return env.Undefined();
+    }
+
+    Napi::Value resize(const Napi::CallbackInfo& info) {
+        const Napi::Env& env = info.Env();
+        _createSwapChain(env);
+        return env.Undefined();
+    }
+
+private:
+
+    void _createSwapChain(const Napi::Env &env) {
+        Napi::Buffer<char> buffer = { env, _window.Get("native") };
+        fprintf(stderr, "_createSwapChain 1\n");
+        // WGPUSurface surface = wgpu::sdl::CreateSurfaceForWindow(procs, _instance, buffer.Data());
+
+        fprintf(stderr, "_createSwapChain 2\n");
+        WGPUSwapChainDescriptor swapChainDesc = {};
+        swapChainDesc.usage = WGPUTextureUsage_RenderAttachment;
+        swapChainDesc.format = WGPUTextureFormat_BGRA8Unorm;
+        swapChainDesc.width = _window.Get("pixelWidth").ToNumber().Uint32Value();
+        fprintf(stderr, "_createSwapChain 3\n");
+        swapChainDesc.height = _window.Get("pixelHeight").ToNumber().Uint32Value();
+
+        fprintf(stderr, "_createSwapChain 4\n");
+        swapChainDesc.presentMode = WGPUPresentMode_Mailbox;
+
+        fprintf(stderr, "_createSwapChain 5\n");
+        // _swapChain = procs.deviceCreateSwapChain(_device, surface, &swapChainDesc);
+
+        fprintf(stderr, "_createSwapChain 6\n");
+    }
+};
+
+Napi::FunctionReference Renderer::constructor;
+
+Napi::Value RenderGPUDeviceToWindow(const Napi::CallbackInfo& info) {
+    const Napi::Env& env = info.Env();
+
+    if (info.Length() != 1) {
+        Napi::Error::New(env, "renderGPUDeviceToWindow expects exactly 1 argument").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    Napi::Value jsArg = info[0];
+
+    if (!jsArg.IsObject()) {
+        Napi::Error::New(env, "argument to renderGPUDeviceToWindow must be an object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    Napi::Object jsObj = jsArg.ToObject();
+
+    Napi::Value jsDevice = jsObj.Get("device");
+    if (!jsDevice.IsObject()) {
+        Napi::Error::New(env, "device argument to renderGPUDeviceToWindow must be an object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    Napi::Value jsWindow = jsObj.Get("window");
+    if (!jsWindow.IsObject()) {
+        Napi::Error::New(env, "window argument to renderGPUDeviceToWindow must be an object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    return Renderer::NewInstance(env, jsDevice, jsWindow);
+}
+
 #ifdef DAWN_EMIT_COVERAGE
 struct Coverage {
     Coverage() : output_path_{GetOutputPath()} {
@@ -106,7 +246,8 @@ struct Coverage {
 // object.
 NAPI_MODULE_EXPORT Napi::Object Initialize(Napi::Env env, Napi::Object exports) {
     // Set all the Dawn procedure function pointers.
-    dawnProcSetProcs(&dawn::native::GetProcs());
+    procs = dawn::native::GetProcs();
+    dawnProcSetProcs(&procs);
 
     // Register all the interop types
     exports.Set(Napi::String::New(env, "globals"), wgpu::interop::Initialize(env));
@@ -114,6 +255,10 @@ NAPI_MODULE_EXPORT Napi::Object Initialize(Napi::Env env, Napi::Object exports)
     // Export function that creates and returns the wgpu::interop::GPU interface
     exports.Set(Napi::String::New(env, "create"), Napi::Function::New<CreateGPU>(env));
 
+    exports.Set(Napi::String::New(env, "renderGPUDeviceToWindow"), Napi::Function::New<RenderGPUDeviceToWindow>(env));
+
+    Renderer::Init(env);
+
 #ifdef DAWN_EMIT_COVERAGE
     Coverage* coverage = new Coverage();
     auto coverage_provider = Napi::Object::New(env);
diff --git a/src/dawn/node/binding/GPUDevice.h b/src/dawn/node/binding/GPUDevice.h
index 82fc4e1e..be31c203 100644
--- a/src/dawn/node/binding/GPUDevice.h
+++ b/src/dawn/node/binding/GPUDevice.h
@@ -114,11 +114,12 @@ class GPUDevice final : public interop::GPUDevice {
         std::optional<std::variant<interop::EventListenerOptions, bool>> options) override;
     bool dispatchEvent(Napi::Env, interop::Interface<interop::Event> event) override;
 
+    wgpu::Device device_;
+
   private:
     void QueueTick();
 
     Napi::Env env_;
-    wgpu::Device device_;
     std::shared_ptr<AsyncRunner> async_;
 
     // This promise's JS object lives as long as the device because it is stored in .lost
diff --git a/src/dawn/samples/CMakeLists.txt b/src/dawn/samples/CMakeLists.txt
index 1a043f7f..c7fa91ea 100644
--- a/src/dawn/samples/CMakeLists.txt
+++ b/src/dawn/samples/CMakeLists.txt
@@ -62,4 +62,3 @@ target_link_libraries(Animometer dawn_sample_utils)
 add_executable(DawnInfo "DawnInfo.cpp")
 common_compile_options(DawnInfo)
 target_link_libraries(DawnInfo dawn_sample_utils)
-
diff --git a/src/dawn/sdl/BUILD.gn b/src/dawn/sdl/BUILD.gn
new file mode 100644
index 00000000..e21b8881
--- /dev/null
+++ b/src/dawn/sdl/BUILD.gn
@@ -0,0 +1,50 @@
+# Copyright 2022 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.
+
+import("../../../scripts/dawn_overrides_with_defaults.gni")
+
+import("${dawn_root}/scripts/dawn_component.gni")
+import("${dawn_root}/scripts/dawn_features.gni")
+
+###############################################################################
+# SDL utils
+###############################################################################
+
+static_library("sdl") {
+  defines = [ "WGPU_SDL_IMPLEMENTATION" ]
+
+  sources = [ "utils.cpp" ]
+  deps = [
+    "${dawn_root}/src/dawn:cpp",
+    "${dawn_root}/src/dawn:proc",
+    "${dawn_root}/src/dawn/common",
+  ]
+
+  public_deps = [
+    "${dawn_root}/include/dawn:cpp_headers",
+  ]
+}
diff --git a/src/dawn/sdl/CMakeLists.txt b/src/dawn/sdl/CMakeLists.txt
new file mode 100644
index 00000000..f8f8a79c
--- /dev/null
+++ b/src/dawn/sdl/CMakeLists.txt
@@ -0,0 +1,49 @@
+# Copyright 2022 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.
+
+add_library(dawn_sdl STATIC ${DAWN_PLACEHOLDER_FILE})
+common_compile_options(dawn_sdl)
+target_sources(dawn_sdl
+  INTERFACE
+    "${DAWN_INCLUDE_DIR}/webgpu/webgpu_sdl.h"
+  PRIVATE
+    "utils.cpp"
+)
+target_link_libraries(dawn_sdl
+  PUBLIC
+    dawncpp_headers
+    dawn_common
+  PRIVATE
+    dawn_internal_config
+)
+
+target_compile_definitions(dawn_sdl PRIVATE "WGPU_IMPLEMENTATION")
+if(BUILD_SHARED_LIBS)
+    target_compile_definitions(dawn_sdl PRIVATE "WGPU_SHARED_LIBRARY")
+endif()
+
+add_library(webgpu_sdl ALIAS dawn_sdl)
diff --git a/src/dawn/sdl/utils.cpp b/src/dawn/sdl/utils.cpp
new file mode 100644
index 00000000..711782d9
--- /dev/null
+++ b/src/dawn/sdl/utils.cpp
@@ -0,0 +1,92 @@
+// Copyright 2020 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 <cstdlib>
+#include <memory>
+#include <utility>
+
+#include "dawn/dawn_proc.h"
+#include "dawn/common/Log.h"
+#include "dawn/common/Platform.h"
+#include "webgpu/webgpu_sdl.h"
+
+namespace wgpu::sdl {
+
+#if DAWN_PLATFORM_IS(WINDOWS)
+    #include <windows.h>
+    struct NativeData {
+        HWND hwnd;
+        HINSTANCE hinstance;
+    };
+#elif defined(DAWN_ENABLE_BACKEND_METAL)
+    class CALayer;
+    struct NativeData {
+        CALayer *layer;
+    };
+#elif defined(DAWN_USE_X11)
+    #include <X11/Xlib.h>
+    struct NativeData {
+        Display* display;
+        Window window;
+    };
+#endif
+
+std::unique_ptr<wgpu::ChainedStruct> SetupWindowAndGetSurfaceDescriptor(void* native) {
+#if DAWN_PLATFORM_IS(WINDOWS)
+    std::unique_ptr<wgpu::SurfaceDescriptorFromWindowsHWND> desc =
+        std::make_unique<wgpu::SurfaceDescriptorFromWindowsHWND>();
+    desc->hwnd = ((NativeData*) native)->hwnd;
+    desc->hinstance = ((NativeData*) native)->hinstance;
+    return std::move(desc);
+#elif defined(DAWN_ENABLE_BACKEND_METAL)
+    std::unique_ptr<wgpu::SurfaceDescriptorFromMetalLayer> desc =
+        std::make_unique<wgpu::SurfaceDescriptorFromMetalLayer>();
+    desc->layer = ((NativeData*) native)->layer;
+    return std::move(desc);
+#elif defined(DAWN_USE_X11)
+    std::unique_ptr<wgpu::SurfaceDescriptorFromXlibWindow> desc =
+        std::make_unique<wgpu::SurfaceDescriptorFromXlibWindow>();
+    desc->display = ((NativeData*) native)->display;
+    desc->window = ((NativeData*) native)->window;
+    return std::move(desc);
+#else
+    return nullptr;
+#endif
+}
+
+WGPUSurface CreateSurfaceForWindow(DawnProcTable &procs, const WGPUInstance& instance, void* window) {
+    std::unique_ptr<wgpu::ChainedStruct> chainedDescriptor =
+        SetupWindowAndGetSurfaceDescriptor(window);
+
+    WGPUSurfaceDescriptor surfaceDesc;
+    surfaceDesc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(chainedDescriptor.get());
+    WGPUSurface surface = procs.instanceCreateSurface(instance, &surfaceDesc);
+
+    return surface;
+}
+
+}  // namespace wgpu::sdl