[dawn] Make spontaneous device callbacks thread safe in native also.

- Unifies the code used for a lot of the device callbacks between the
  wire client and native. Note that I am currently using dawn/common
  for convenience, but it might be better in the long run to use
  another target or something since I needed to explicitly exclude
  the helpers for WASM builds since the logging callback is currently
  native only.

Change-Id: Ia244a3dab0c9244d6a277c31d857210c9d3fc554
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/297575
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Loko Kung <lokokung@google.com>

Author: lokokung

src/dawn/common/BUILD.gn

@@ -401,6 +401,13 @@ if (is_win || is_linux || is_chromeos || is_mac || is_fuchsia || is_android ||
     ]
     sources += get_target_outputs(":dawn_gpu_info_gen")
 
+    if (!is_wasm) {
+      sources += [
+        "WGPUDeviceCallbackInfos.cpp",
+        "WGPUDeviceCallbackInfos.h",
+      ]
+    }
+
     public_deps = [
       ":dawn_gpu_info_gen",
       ":dawn_version_gen",

src/dawn/common/CMakeLists.txt

@@ -133,15 +133,15 @@ set(sources
 set(conditional_private_depends)
 
 if (WIN32)
-    list(APPEND headers
+    list(APPEND private_headers
         "windows_with_undefs.h"
         "WindowsUtils.h"
     )
     list(APPEND sources
         "WindowsUtils.cpp"
     )
 elseif(APPLE)
-    list(APPEND headers
+    list(APPEND private_headers
         "IOSurfaceUtils.h"
     )
     list(APPEND sources
@@ -154,6 +154,15 @@ elseif(APPLE)
     )
 endif()
 
+if (NOT EMSCRIPTEN)
+    list(APPEND private_headers
+        "WGPUDeviceCallbackInfos.h"
+    )
+    list(APPEND sources
+        "WGPUDeviceCallbackInfos.cpp"
+    )
+endif()
+
 if (CMAKE_SYSTEM_NAME STREQUAL "Android")
     find_library(log_lib log)
     list(APPEND conditional_private_depends

src/dawn/common/WGPUDeviceCallbackInfos.cpp

@@ -0,0 +1,181 @@
+// Copyright 2026 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "dawn/common/WGPUDeviceCallbackInfos.h"
+
+#include "dawn/common/Log.h"
+
+namespace dawn {
+namespace {
+// Default callback infos depending on the build type.
+#ifdef DAWN_ENABLE_ASSERTS
+static constexpr WGPUDeviceLostCallbackInfo kDefaultDeviceLostCallbackInfo = {
+    nullptr, WGPUCallbackMode_AllowSpontaneous,
+    [](WGPUDevice const*, WGPUDeviceLostReason, WGPUStringView, void*, void*) {
+        static std::once_flag flag;
+        std::call_once(flag, []() {
+            dawn::WarningLog() << "No Dawn device lost callback was set. This is probably not "
+                                  "intended. If you really want to ignore device lost "
+                                  "and suppress this message, set the callback explicitly.";
+        });
+    },
+    nullptr, nullptr};
+static constexpr WGPUUncapturedErrorCallbackInfo kDefaultUncapturedErrorCallbackInfo = {
+    nullptr,
+    [](WGPUDevice const*, WGPUErrorType, WGPUStringView, void*, void*) {
+        static std::once_flag flag;
+        std::call_once(flag, []() {
+            dawn::WarningLog() << "No Dawn device uncaptured error callback was set. This is "
+                                  "probably not intended. If you really want to ignore errors "
+                                  "and suppress this message, set the callback explicitly.";
+        });
+    },
+    nullptr, nullptr};
+static constexpr WGPULoggingCallbackInfo kDefaultLoggingCallbackInfo = {
+    nullptr,
+    [](WGPULoggingType, WGPUStringView, void*, void*) {
+        static std::once_flag flag;
+        std::call_once(flag, []() {
+            dawn::WarningLog() << "No Dawn device logging callback callback was set. This is "
+                                  "probably not intended. If you really want to ignore logs "
+                                  "and suppress this message, set the callback explicitly.";
+        });
+    },
+    nullptr, nullptr};
+#else
+static constexpr WGPUDeviceLostCallbackInfo kDefaultDeviceLostCallbackInfo = {
+    nullptr, WGPUCallbackMode_AllowSpontaneous, nullptr, nullptr, nullptr};
+static constexpr WGPUUncapturedErrorCallbackInfo kDefaultUncapturedErrorCallbackInfo = {
+    nullptr, nullptr, nullptr, nullptr};
+static constexpr WGPULoggingCallbackInfo kDefaultLoggingCallbackInfo = {nullptr, nullptr, nullptr,
+                                                                        nullptr};
+#endif  // DAWN_ENABLE_ASSERTS
+
+const WGPUUncapturedErrorCallbackInfo& GetUncapturedErrorCallbackInfoOrDefault(
+    const WGPUDeviceDescriptor* descriptor) {
+    if (descriptor != nullptr && descriptor->uncapturedErrorCallbackInfo.callback != nullptr) {
+        return descriptor->uncapturedErrorCallbackInfo;
+    }
+    return kDefaultUncapturedErrorCallbackInfo;
+}
+}  // namespace
+
+const WGPUDeviceLostCallbackInfo& GetDeviceLostCallbackInfoOrDefault(
+    const WGPUDeviceDescriptor* descriptor) {
+    if (descriptor != nullptr && descriptor->deviceLostCallbackInfo.callback != nullptr) {
+        return descriptor->deviceLostCallbackInfo;
+    }
+    return kDefaultDeviceLostCallbackInfo;
+}
+
+WGPUDeviceCallbackInfos::CallbackInfos::CallbackInfos() = default;
+
+WGPUDeviceCallbackInfos::CallbackInfos::CallbackInfos(const WGPUUncapturedErrorCallbackInfo& error,
+                                                      const WGPULoggingCallbackInfo& logging) {
+    if (error.callback != nullptr) {
+        this->error = error;
+    }
+    if (logging.callback != nullptr) {
+        this->logging = logging;
+    }
+}
+
+WGPUDeviceCallbackInfos::WGPUDeviceCallbackInfos() = default;
+
+WGPUDeviceCallbackInfos::WGPUDeviceCallbackInfos(const WGPUDeviceDescriptor* descriptor)
+    : mCallbackInfos(GetUncapturedErrorCallbackInfoOrDefault(descriptor),
+                     kDefaultLoggingCallbackInfo) {}
+
+void WGPUDeviceCallbackInfos::CallErrorCallback(WGPUDevice const* device,
+                                                WGPUErrorType type,
+                                                WGPUStringView message) {
+    std::optional<WGPUUncapturedErrorCallbackInfo> callbackInfo;
+    mCallbackInfos.Use<NotifyType::None>([&](auto callbackInfos) {
+        callbackInfo = callbackInfos->error;
+        if (callbackInfo) {
+            callbackInfos->semaphore += 1;
+        }
+    });
+
+    // If we don't have a callback info, we can just return.
+    if (!callbackInfo) {
+        return;
+    }
+
+    // Call the callback without holding the lock to prevent any re-entrant issues.
+    DAWN_ASSERT(callbackInfo->callback != nullptr);
+    callbackInfo->callback(device, type, message, callbackInfo->userdata1, callbackInfo->userdata2);
+
+    mCallbackInfos.Use([&](auto callbackInfos) {
+        DAWN_ASSERT(callbackInfos->semaphore > 0);
+        callbackInfos->semaphore -= 1;
+    });
+}
+
+void WGPUDeviceCallbackInfos::CallLoggingCallback(WGPULoggingType type, WGPUStringView message) {
+    std::optional<WGPULoggingCallbackInfo> callbackInfo;
+    mCallbackInfos.Use<NotifyType::None>([&](auto callbackInfos) {
+        callbackInfo = callbackInfos->logging;
+        if (callbackInfo) {
+            callbackInfos->semaphore += 1;
+        }
+    });
+
+    // If we don't have a callback info, we can just return.
+    if (!callbackInfo) {
+        return;
+    }
+
+    // Call the callback without holding the lock to prevent any re-entrant issues.
+    DAWN_ASSERT(callbackInfo->callback != nullptr);
+    callbackInfo->callback(type, message, callbackInfo->userdata1, callbackInfo->userdata2);
+
+    mCallbackInfos.Use([&](auto callbackInfos) {
+        DAWN_ASSERT(callbackInfos->semaphore > 0);
+        callbackInfos->semaphore -= 1;
+    });
+}
+
+void WGPUDeviceCallbackInfos::SetLoggingCallbackInfo(const WGPULoggingCallbackInfo& callbackInfo) {
+    mCallbackInfos.Use<NotifyType::None>(
+        [&](auto callbackInfos) { callbackInfos->logging = callbackInfo; });
+}
+
+void WGPUDeviceCallbackInfos::Clear() {
+    mCallbackInfos.Use<NotifyType::None>([](auto callbackInfos) {
+        callbackInfos->error = std::nullopt;
+        callbackInfos->logging = std::nullopt;
+
+        // The uncaptured error and logging callbacks are spontaneous and must not be called
+        // after we call the device lost's |mCallback| below. Although we have cleared those
+        // callbacks, we need to wait for any remaining outstanding callbacks to finish before
+        // continuing.
+        callbackInfos.Wait([](auto& x) { return x.semaphore == 0; });
+    });
+}
+
+}  // namespace dawn

src/dawn/common/WGPUDeviceCallbackInfos.h

@@ -0,0 +1,85 @@
+// Copyright 2026 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 SRC_DAWN_COMMON_WGPUDEVICECALLBACKINFOS_H_
+#define SRC_DAWN_COMMON_WGPUDEVICECALLBACKINFOS_H_
+
+#include <webgpu/webgpu.h>
+
+#include <optional>
+
+#include "dawn/common/MutexProtected.h"
+
+namespace dawn {
+
+const WGPUDeviceLostCallbackInfo& GetDeviceLostCallbackInfoOrDefault(
+    const WGPUDeviceDescriptor* descriptor);
+
+// Device level unconditionally spontaneous callbacks need to be synchronized so this class provides
+// a common wrapper for those callback infos so that the implementation can be shared across native
+// and wire client.
+class WGPUDeviceCallbackInfos {
+  public:
+    WGPUDeviceCallbackInfos();
+    explicit WGPUDeviceCallbackInfos(const WGPUDeviceDescriptor* descriptor);
+
+    // APIs to call the callbacks.
+    void CallErrorCallback(WGPUDevice const* device, WGPUErrorType type, WGPUStringView message);
+    void CallLoggingCallback(WGPULoggingType type, WGPUStringView message);
+
+    // The logging callback currently needs to support a setter.
+    void SetLoggingCallbackInfo(const WGPULoggingCallbackInfo& callbackInfo);
+
+    // Used when the device is lost and we want to clear out the callbacks. This helper waits until
+    // there are no other places using the callbacks before returning. This is important since this
+    // is generally used when completing the device lost event which users may use to clean up the
+    // uncaptured error and logging callbacks.
+    void Clear();
+
+  private:
+    struct CallbackInfos {
+        CallbackInfos();
+        CallbackInfos(const WGPUUncapturedErrorCallbackInfo& error,
+                      const WGPULoggingCallbackInfo& logging);
+
+        // The callback infos are optional because once the device is lost, they are set to
+        // std::nullopt and no longer do anything.
+        std::optional<WGPUUncapturedErrorCallbackInfo> error = std::nullopt;
+        std::optional<WGPULoggingCallbackInfo> logging = std::nullopt;
+
+        // Counter that tracks how many places are currently using callback infos. This is used to
+        // ensure that before we call the device lost callback (which may deallocate the uncaptured
+        // error and logging callbacks), we have ensured that there are no outstanding references to
+        // those callbacks.
+        uint32_t semaphore = 0;
+    };
+    MutexCondVarProtected<CallbackInfos> mCallbackInfos;
+};
+
+}  // namespace dawn
+
+#endif  // SRC_DAWN_COMMON_WGPUDEVICECALLBACKINFOS_H_