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/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..36e5b94f 100644
--- a/src/dawn/node/Module.cpp
+++ b/src/dawn/node/Module.cpp
@@ -34,7 +34,11 @@
 #include "dawn/dawn_proc.h"
 #include "src/dawn/node/binding/Flags.h"
 #include "src/dawn/node/binding/GPU.h"
-#include "tint/tint.h"
+#include "src/dawn/node/binding/GPUDevice.h"
+#include "src/dawn/node/binding/GPUTexture.h"
+#include "src/dawn/node/binding/GPUTextureView.h"
+
+#include "webgpu/webgpu_sdl.h"
 
 #ifdef DAWN_EMIT_COVERAGE
 extern "C" {
@@ -46,8 +50,12 @@ int __llvm_profile_write_file(void);
 
 namespace {
 
+DawnProcTable procs;
+
+Napi::Reference<Napi::Array> gpuArrayRef;
+
 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);
@@ -70,7 +78,221 @@ Napi::Value CreateGPU(const Napi::CallbackInfo& info) {
     }
 
     // Construct a wgpu::interop::GPU interface, implemented by wgpu::bindings::GPU.
-    return wgpu::interop::GPU::Create<wgpu::binding::GPU>(env, std::move(flags));
+    auto gpu = wgpu::interop::GPU::Create<wgpu::binding::GPU>(env, std::move(flags));
+    Napi::Object jsGpu = gpu;
+
+    if (gpuArrayRef.IsEmpty()) {
+        Napi::Array jsArray = Napi::Array::New(env);
+        gpuArrayRef = Napi::Persistent(jsArray);
+        gpuArrayRef.SuppressDestruct();
+    }
+    Napi::Array jsArray = gpuArrayRef.Value();
+    jsArray.Set(jsArray.Length(), jsGpu);
+
+    return jsGpu;
+}
+
+Napi::Env *callbackEnv;
+
+Napi::Value ProcessEvents(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    callbackEnv = &env;
+
+    Napi::Array jsArray = gpuArrayRef.Value();
+    int len = jsArray.Length();
+    for (int i = 0 ; i < len; i++) {
+        Napi::Object jsGpu = jsArray.Get(i).ToObject();
+        wgpu::binding::GPU *gpu = reinterpret_cast<wgpu::binding::GPU*>(wgpu::interop::GPU::Unwrap(jsGpu));
+        WGPUInstance wgpuInstance = gpu->instance_.Get();
+        procs.instanceProcessEvents(wgpuInstance);
+    }
+    return env.Undefined();
+}
+
+void DeviceErrorCallback(WGPUErrorType errorType, const char* message, void*) {
+    std::string errorTypeName;
+    switch (errorType) {
+        case WGPUErrorType_Validation:
+            errorTypeName = "Validation";
+            break;
+        case WGPUErrorType_OutOfMemory:
+            errorTypeName = "Out of memory";
+            break;
+        case WGPUErrorType_Unknown:
+            errorTypeName = "Unknown";
+            break;
+        case WGPUErrorType_DeviceLost:
+            errorTypeName = "Device lost";
+            break;
+        default:
+            return;
+    }
+
+    std::string error = "WebGPU unhandled error: " + errorTypeName + " error: " + message;
+    callbackEnv->Global()
+        .Get("setImmediate")
+        .As<Napi::Function>()
+        .Call({
+            Napi::Function::New(
+                *callbackEnv,
+                [error](const Napi::CallbackInfo& info) {
+                    const Napi::Env &env = info.Env();
+                    Napi::Error::New(env, error).ThrowAsJavaScriptException();
+                }
+            )
+        });
+}
+
+void DeviceLostCallback(WGPUDeviceLostReason reason, const char* message, void*) {
+    std::string error = "WebGPU Device lost: " + std::string(message);
+    callbackEnv->Global()
+        .Get("setImmediate")
+        .As<Napi::Function>()
+        .Call({ Napi::Function::New(*callbackEnv, [error](const Napi::CallbackInfo&) { std::cerr << error; }) });
+}
+
+void DeviceLogCallback(WGPULoggingType type, const char* message, void*) {
+    std::string error = "WebGPU Device log: " + std::string(message);
+    callbackEnv->Global()
+        .Get("setImmediate")
+        .As<Napi::Function>()
+        .Call({ Napi::Function::New(*callbackEnv, [error](const Napi::CallbackInfo&) { std::cerr << error; }) });
+}
+
+Napi::FunctionReference constructor;
+
+class Renderer : public Napi::ObjectWrap<Renderer> {
+
+public:
+
+    Napi::ObjectReference _device;
+    Napi::ObjectReference _window;
+    WGPUSwapChain _wgpuSwapChain;
+
+    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>();
+        _device = Napi::Persistent(jsDevice);
+
+        WGPUDevice wgpuDevice = getWGPUDevice();
+
+        procs.deviceSetUncapturedErrorCallback(wgpuDevice, DeviceErrorCallback, nullptr);
+        procs.deviceSetDeviceLostCallback(wgpuDevice, DeviceLostCallback, nullptr);
+        procs.deviceSetLoggingCallback(wgpuDevice, DeviceLogCallback, nullptr);
+
+        auto jsWindow = info[1].As<Napi::Object>();
+        _window = Napi::Persistent(jsWindow);
+
+        _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(_wgpuSwapChain);
+        return wgpu::interop::GPUTexture::Create<wgpu::binding::GPUTexture>(env,
+            wgpu::Device::Acquire(getWGPUDevice()),
+            wgpu::TextureDescriptor(),
+            wgpu::Texture::Acquire(texture)
+        );
+    }
+
+    Napi::Value getCurrentTextureView(const Napi::CallbackInfo& info) {
+        const Napi::Env& env = info.Env();
+        WGPUTextureView textureView = procs.swapChainGetCurrentTextureView(_wgpuSwapChain);
+        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(_wgpuSwapChain);
+        return env.Undefined();
+    }
+
+    Napi::Value resize(const Napi::CallbackInfo& info) {
+        const Napi::Env& env = info.Env();
+        _createSwapChain(env);
+        return env.Undefined();
+    }
+
+private:
+
+    WGPUDevice getWGPUDevice() {
+        return reinterpret_cast<wgpu::binding::GPUDevice*>(wgpu::interop::GPUDevice::Unwrap(_device.Value()))->device_.Get();
+    }
+
+    void _createSwapChain(const Napi::Env &env) {
+        WGPUDevice wgpuDevice = getWGPUDevice();
+        WGPUAdapter wgpuAdapter = procs.deviceGetAdapter(wgpuDevice);
+        WGPUInstance wgpuInstance = procs.adapterGetInstance(wgpuAdapter);
+
+        Napi::Buffer<char> buffer = { env, _window.Get("_native") };
+        WGPUSurface wgpuSurface = wgpu::sdl::CreateSurfaceForWindow(procs, wgpuInstance, buffer.Data());
+
+        WGPUSwapChainDescriptor wgpuSwapChainDesc = {};
+        wgpuSwapChainDesc.usage = WGPUTextureUsage_RenderAttachment;
+        wgpuSwapChainDesc.format = WGPUTextureFormat_BGRA8Unorm;
+        wgpuSwapChainDesc.width = _window.Get("_pixelWidth").ToNumber().Uint32Value();
+        wgpuSwapChainDesc.height = _window.Get("_pixelHeight").ToNumber().Uint32Value();
+        wgpuSwapChainDesc.presentMode = WGPUPresentMode_Mailbox;
+
+        _wgpuSwapChain = procs.deviceCreateSwapChain(wgpuDevice, wgpuSurface, &wgpuSwapChainDesc);
+    }
+};
+
+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
@@ -106,7 +328,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 +337,12 @@ 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, "_processEvents"), Napi::Function::New<ProcessEvents>(env));
+
+    Renderer::Init(env);
+
+    exports.Set(Napi::String::New(env, "renderGPUDeviceToWindow"), Napi::Function::New<RenderGPUDeviceToWindow>(env));
+
 #ifdef DAWN_EMIT_COVERAGE
     Coverage* coverage = new Coverage();
     auto coverage_provider = Napi::Object::New(env);
diff --git a/src/dawn/node/binding/GPU.h b/src/dawn/node/binding/GPU.h
index 89533054..ef95cefe 100644
--- a/src/dawn/node/binding/GPU.h
+++ b/src/dawn/node/binding/GPU.h
@@ -48,9 +48,10 @@ class GPU final : public interop::GPU {
     interop::GPUTextureFormat getPreferredCanvasFormat(Napi::Env) override;
     interop::Interface<interop::WGSLLanguageFeatures> getWgslLanguageFeatures(Napi::Env) override;
 
+    dawn::native::Instance instance_;
+
   private:
     const Flags flags_;
-    dawn::native::Instance instance_;
 };
 
 }  // namespace wgpu::binding
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..9e04d860
--- /dev/null
+++ b/src/dawn/sdl/utils.cpp
@@ -0,0 +1,91 @@
+// 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> GetSurfaceDescriptor(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 = GetSurfaceDescriptor(window);
+
+    WGPUSurfaceDescriptor surfaceDesc;
+    surfaceDesc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(chainedDescriptor.get());
+    WGPUSurface surface = procs.instanceCreateSurface(instance, &surfaceDesc);
+
+    return surface;
+}
+
+}  // namespace wgpu::sdl