[deno] Use error impl from core

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

Author: sagudev

deno_webgpu/adapter.rs

@@ -20,9 +20,11 @@ use super::device::GPUDevice;
 use super::device::DEVICE_EXTERNAL_MEMORY_SIZE;
 use super::queue::GPUQueue;
 use crate::device::GPUDeviceLostInfo;
+use crate::error::GPUError;
 use crate::error::GPUGenericError;
 use crate::webidl::GPUFeatureName;
 use crate::LostPromiseResolverHM;
+use crate::WeakDeviceHM;
 
 #[derive(WebIDL)]
 #[webidl(dictionary)]
@@ -251,6 +253,9 @@ impl GPUAdapter {
         op_state
           .borrow_mut::<LostPromiseResolverHM>()
           .remove(&wgpu_device_id);
+        op_state
+          .borrow_mut::<WeakDeviceHM>()
+          .remove(&wgpu_device_id);
       }),
     );
 
@@ -260,7 +265,57 @@ impl GPUAdapter {
     let device_ref =
       deno_core::cppgc::try_unwrap_cppgc_object::<GPUDevice>(scope, device)
         .unwrap();
-    device_ref.error_handler.set_device(weak_device);
+
+    let cross_thread_spawner =
+      state.borrow::<V8CrossThreadTaskSpawner>().clone();
+    state
+      .borrow_mut::<WeakDeviceHM>()
+      .insert(wgpu_device_id, weak_device);
+    let wake = Arc::new(Mutex::new(move |error: wgpu_types::error::Error| {
+      cross_thread_spawner.spawn(move |scope| {
+        let state = JsRuntime::op_state_from(&*scope);
+        let state = state.borrow();
+        let weak_device =
+          state.borrow::<WeakDeviceHM>().get(&wgpu_device_id).unwrap();
+        let err: GPUError = error.into();
+        let weak_device = weak_device.clone();
+
+        let Some(device) = weak_device.to_local(scope) else {
+          // The device has already gone away, so we don't have
+          // anywhere to report the error.
+          return;
+        };
+        let key = v8::String::new(scope, "dispatchEvent").unwrap();
+        let val = device.get(scope, key.into()).unwrap();
+        let func =
+          v8::Global::new(scope, val.try_cast::<v8::Function>().unwrap());
+        let device = v8::Global::new(scope, device.cast::<v8::Value>());
+        let error_event_class =
+          state.borrow::<crate::ErrorEventClass>().0.clone();
+
+        let error = deno_core::error::to_v8_error(scope, &err);
+
+        let error_event_class =
+          v8::Local::new(scope, error_event_class.clone());
+        let constructor =
+          v8::Local::<v8::Function>::try_from(error_event_class).unwrap();
+        let kind = v8::String::new(scope, "uncapturederror").unwrap();
+
+        let obj = v8::Object::new(scope);
+        let key = v8::String::new(scope, "error").unwrap();
+        obj.set(scope, key.into(), error);
+
+        let event = constructor
+          .new_instance(scope, &[kind.into(), obj.into()])
+          .unwrap();
+
+        let recv = v8::Local::new(scope, device);
+        func.open(scope).call(scope, recv, &[event.into()]);
+      });
+    }));
+    wgpu_device.on_uncaptured_error(Arc::new(move |error| {
+      wake.lock().unwrap()(error);
+    }));
     device_ref.weak.set(finalizer).unwrap();
 
     Ok(v8::Global::new(scope, device))

deno_webgpu/device.rs

@@ -13,6 +13,7 @@ use deno_core::webidl::WebIdlInterfaceConverter;
 use deno_core::GarbageCollected;
 use deno_error::JsErrorBox;
 use wgpu_core::binding_model::BindingResource;
+use wgpu_core::error::EmptyErrorScopeStack;
 use wgpu_core::pipeline::ProgrammableStageDescriptor;
 use wgpu_types::BindingType;
 
@@ -29,7 +30,7 @@ use crate::adapter::GPUAdapterInfo;
 use crate::adapter::GPUSupportedFeatures;
 use crate::adapter::GPUSupportedLimits;
 use crate::command_encoder::GPUCommandEncoder;
-use crate::error::{fmt_err, make_pipeline_error};
+use crate::error::{fmt_err, make_pipeline_error, GPUError};
 use crate::error::{GPUGenericError, GPUPipelineErrorReason};
 use crate::query_set::GPUQuerySet;
 use crate::render_bundle::GPURenderBundleEncoder;
@@ -688,12 +689,7 @@ impl GPUDevice {
   #[required(1)]
   #[undefined]
   fn push_error_scope(&self, #[webidl] filter: super::error::GPUErrorFilter) {
-    self
-      .error_handler
-      .scopes
-      .lock()
-      .unwrap()
-      .push((filter, None));
+    self.wgpu_device.push_error_scope(filter.into());
   }
 
   #[async_method(fake)]
@@ -702,26 +698,21 @@ impl GPUDevice {
     &self,
     scope: &mut v8::HandleScope,
   ) -> Result<v8::Global<v8::Value>, JsErrorBox> {
-    if !self.wgpu_device.is_valid() {
-      let val = v8::null(scope).cast::<v8::Value>();
-      return Ok(v8::Global::new(scope, val));
-    }
-
-    let Some((_, error)) = self.error_handler.scopes.lock().unwrap().pop()
-    else {
-      return Err(JsErrorBox::new(
+    match self.wgpu_device.pop_error_scope() {
+      Ok(maybe_error) => {
+        let val = if let Some(err) = maybe_error {
+          let err: GPUError = err.into();
+          deno_core::error::to_v8_error(scope, &err)
+        } else {
+          v8::null(scope).cast::<v8::Value>()
+        };
+        Ok(v8::Global::new(scope, val))
+      }
+      Err(EmptyErrorScopeStack {}) => Err(JsErrorBox::new(
         "DOMExceptionOperationError",
         "There are no error scopes on the error scope stack",
-      ));
-    };
-
-    let val = if let Some(err) = error {
-      deno_core::error::to_v8_error(scope, &err)
-    } else {
-      v8::null(scope).into()
-    };
-
-    Ok(v8::Global::new(scope, val))
+      )),
+    }
   }
 
   #[fast]

deno_webgpu/error.rs

@@ -2,13 +2,11 @@
 
 use std::fmt::Display;
 use std::fmt::Formatter;
-use std::sync::Mutex;
-use std::sync::OnceLock;
+use std::sync::Arc;
 
 use deno_core::v8;
 
 use deno_core::JsRuntime;
-use deno_core::V8TaskSpawner;
 use wgpu_core::binding_model::CreateBindGroupError;
 use wgpu_core::binding_model::CreateBindGroupLayoutError;
 use wgpu_core::binding_model::CreatePipelineLayoutError;
@@ -24,6 +22,7 @@ use wgpu_core::command::RenderBundleError;
 use wgpu_core::command::RenderPassError;
 use wgpu_core::device::queue::QueueSubmitError;
 use wgpu_core::device::queue::QueueWriteError;
+use wgpu_core::device::Device;
 use wgpu_core::device::DeviceError;
 use wgpu_core::pipeline::CreateComputePipelineError;
 use wgpu_core::pipeline::CreateRenderPipelineError;
@@ -35,31 +34,18 @@ use wgpu_core::resource::CreateQuerySetError;
 use wgpu_core::resource::CreateSamplerError;
 use wgpu_core::resource::CreateTextureError;
 use wgpu_core::resource::CreateTextureViewError;
+use wgpu_types::error::ErrorFilter;
 use wgpu_types::error::{ErrorType, WebGpuError};
 
 pub type ErrorHandler = std::rc::Rc<DeviceErrorHandler>;
 
 pub struct DeviceErrorHandler {
-  pub scopes: Mutex<Vec<(GPUErrorFilter, Option<GPUError>)>>,
-  spawner: V8TaskSpawner,
-
-  // The error handler is constructed before the device. A weak
-  // reference to the device is placed here with `set_device`
-  // after the device is constructed.
-  device: OnceLock<v8::Weak<v8::Object>>,
+  device: Arc<Device>,
 }
 
 impl DeviceErrorHandler {
-  pub fn new(spawner: V8TaskSpawner) -> Self {
-    Self {
-      scopes: Mutex::new(vec![]),
-      device: OnceLock::new(),
-      spawner,
-    }
-  }
-
-  pub fn set_device(&self, device: v8::Weak<v8::Object>) {
-    self.device.set(device).unwrap()
+  pub fn new(device: Arc<Device>) -> Self {
+    Self { device }
   }
 
   pub fn push_error<E: Into<GPUError>>(&self, err: Option<E>) {
@@ -69,64 +55,7 @@ impl DeviceErrorHandler {
 
     let err = err.into();
 
-    let error_filter = match err {
-      GPUError::Lost => return,
-      GPUError::Validation(_) => GPUErrorFilter::Validation,
-      GPUError::OutOfMemory => GPUErrorFilter::OutOfMemory,
-      GPUError::Internal => GPUErrorFilter::Internal,
-    };
-
-    let mut scopes = self.scopes.lock().unwrap();
-    let scope = scopes
-      .iter_mut()
-      .rfind(|(filter, _)| filter == &error_filter);
-
-    if let Some(scope) = scope {
-      // Only saving the first error in the scope as it's likely the culprit.
-      if scope.1.is_none() {
-        scope.1 = Some(err);
-      }
-    } else {
-      let device = self
-        .device
-        .get()
-        .expect("set_device was not called")
-        .clone();
-      self.spawner.spawn(move |scope| {
-        let state = JsRuntime::op_state_from(&*scope);
-        let Some(device) = device.to_local(scope) else {
-          // The device has already gone away, so we don't have
-          // anywhere to report the error.
-          return;
-        };
-        let key = v8::String::new(scope, "dispatchEvent").unwrap();
-        let val = device.get(scope, key.into()).unwrap();
-        let func =
-          v8::Global::new(scope, val.try_cast::<v8::Function>().unwrap());
-        let device = v8::Global::new(scope, device.cast::<v8::Value>());
-        let error_event_class =
-          state.borrow().borrow::<crate::ErrorEventClass>().0.clone();
-
-        let error = deno_core::error::to_v8_error(scope, &err);
-
-        let error_event_class =
-          v8::Local::new(scope, error_event_class.clone());
-        let constructor =
-          v8::Local::<v8::Function>::try_from(error_event_class).unwrap();
-        let kind = v8::String::new(scope, "uncapturederror").unwrap();
-
-        let obj = v8::Object::new(scope);
-        let key = v8::String::new(scope, "error").unwrap();
-        obj.set(scope, key.into(), error);
-
-        let event = constructor
-          .new_instance(scope, &[kind.into(), obj.into()])
-          .unwrap();
-
-        let recv = v8::Local::new(scope, device);
-        func.open(scope).call(scope, recv, &[event.into()]);
-      });
-    }
+    self.device.handle_error_nolabel(err, "");
   }
 }
 
@@ -138,6 +67,16 @@ pub enum GPUErrorFilter {
   Internal,
 }
 
+impl From<GPUErrorFilter> for ErrorFilter {
+  fn from(filter: GPUErrorFilter) -> Self {
+    match filter {
+      GPUErrorFilter::Validation => ErrorFilter::Validation,
+      GPUErrorFilter::OutOfMemory => ErrorFilter::OutOfMemory,
+      GPUErrorFilter::Internal => ErrorFilter::Internal,
+    }
+  }
+}
+
 #[derive(Debug, deno_error::JsError)]
 pub enum GPUError {
   // TODO(@crowlKats): consider adding an unreachable value that uses unreachable!()
@@ -165,16 +104,46 @@ impl Display for GPUError {
 impl std::error::Error for GPUError {}
 
 impl GPUError {
-  fn from_webgpu(e: impl WebGpuError) -> Self {
+  pub(crate) fn from_webgpu(e: impl WebGpuError) -> Self {
     match e.webgpu_error_type() {
       ErrorType::Internal => GPUError::Internal,
-      ErrorType::DeviceLost => GPUError::Lost, // TODO: this variant should be ignored, register the lost callback instead.
+      ErrorType::DeviceLost => GPUError::Lost, // this will be ignored by handle_error in wgpu-core
       ErrorType::OutOfMemory => GPUError::OutOfMemory,
       ErrorType::Validation => GPUError::Validation(fmt_err(&e)),
     }
   }
 }
 
+impl From<wgpu_types::error::Error> for GPUError {
+  fn from(err: wgpu_types::error::Error) -> Self {
+    match err {
+      wgpu_types::error::Error::Validation {
+        description,
+        source,
+      } => {
+        if let Some(e) = source.source() {
+          GPUError::Validation(fmt_err(e))
+        } else {
+          GPUError::Validation(description)
+        }
+      }
+      wgpu_types::error::Error::OutOfMemory { .. } => GPUError::OutOfMemory,
+      wgpu_types::error::Error::Internal { .. } => GPUError::Internal,
+    }
+  }
+}
+
+impl WebGpuError for GPUError {
+  fn webgpu_error_type(&self) -> ErrorType {
+    match self {
+      GPUError::Lost => ErrorType::DeviceLost,
+      GPUError::Validation(_) => ErrorType::Validation,
+      GPUError::OutOfMemory => ErrorType::OutOfMemory,
+      GPUError::Internal => ErrorType::Internal,
+    }
+  }
+}
+
 pub(crate) fn fmt_err(err: &(dyn std::error::Error + 'static)) -> String {
   let mut output = err.to_string();
 

deno_webgpu/lib.rs

@@ -1,6 +1,7 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 #![cfg(not(target_arch = "wasm32"))]
 #![warn(unsafe_op_in_unsafe_fn)]
+#![allow(clippy::disallowed_types)]
 
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -115,6 +116,7 @@ deno_core::extension!(
   lazy_loaded_esm = ["01_webgpu.js"],
 );
 
+pub(crate) type WeakDeviceHM = HashMap<usize, v8::Weak<v8::Object>>;
 pub(crate) type LostPromiseResolverHM =
   HashMap<usize, v8::Global<v8::PromiseResolver>>;
 
@@ -128,6 +130,7 @@ pub fn op_create_gpu(
   uncaptured_error_event_class: v8::Local<v8::Value>,
   pipeline_error_class: v8::Local<v8::Value>,
 ) -> GPU {
+  state.put(WeakDeviceHM::new());
   state.put(LostPromiseResolverHM::new());
   state.put(EventTargetSetup {
     brand: v8::Global::new(scope, webidl_brand),