webgpu: leverage routed_promise in calls returning promises (#35859)

Using the RoutedPromiseListener let us define a different
response type for each promise. This removes unreachable branches
that used to exist when they all shared the same WebGPUResponse.

Signed-off-by: webbeef <me@webbeef.org>

components/script/dom/servointernals.rs

@@ -52,11 +52,8 @@ impl ServoInternalsMethods<crate::DomTypeHolder> for ServoInternals {
     }
 }
 
-impl RoutedPromiseListener for ServoInternals {
-    type Response = MemoryReportResult;
-
-    #[cfg_attr(crown, allow(crown::unrooted_must_root))]
-    fn handle_response(&self, response: Self::Response, promise: &Rc<Promise>, can_gc: CanGc) {
+impl RoutedPromiseListener<MemoryReportResult> for ServoInternals {
+    fn handle_response(&self, response: MemoryReportResult, promise: &Rc<Promise>, can_gc: CanGc) {
         promise.resolve_native(&response.content, can_gc);
     }
 }

components/script/dom/webgpu/gpu.rs

@@ -5,26 +5,24 @@
 use std::rc::Rc;
 
 use dom_struct::dom_struct;
-use ipc_channel::ipc::{self, IpcSender};
-use ipc_channel::router::ROUTER;
 use js::jsapi::Heap;
 use script_traits::ScriptMsg;
 use webgpu::wgt::PowerPreference;
-use webgpu::{WebGPUResponse, wgc};
+use webgpu::{WebGPUAdapterResponse, wgc};
 
 use super::wgsllanguagefeatures::WGSLLanguageFeatures;
 use crate::dom::bindings::codegen::Bindings::WebGPUBinding::{
     GPUMethods, GPUPowerPreference, GPURequestAdapterOptions, GPUTextureFormat,
 };
 use crate::dom::bindings::error::Error;
-use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
-use crate::dom::bindings::reflector::{DomGlobal, DomObject, Reflector, reflect_dom_object};
+use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
 use crate::dom::bindings::root::{DomRoot, MutNullableDom};
 use crate::dom::bindings::str::DOMString;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
 use crate::dom::webgpu::gpuadapter::GPUAdapter;
 use crate::realms::InRealm;
+use crate::routed_promise::{RoutedPromiseListener, route_promise};
 use crate::script_runtime::CanGc;
 
 #[dom_struct]
@@ -48,59 +46,6 @@ impl GPU {
     }
 }
 
-pub(crate) trait AsyncWGPUListener {
-    fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>, can_gc: CanGc);
-}
-
-struct WGPUResponse<T: AsyncWGPUListener + DomObject> {
-    trusted: TrustedPromise,
-    receiver: Trusted<T>,
-}
-
-impl<T: AsyncWGPUListener + DomObject> WGPUResponse<T> {
-    #[cfg_attr(crown, allow(crown::unrooted_must_root))]
-    fn response(self, response: WebGPUResponse, can_gc: CanGc) {
-        let promise = self.trusted.root();
-        self.receiver
-            .root()
-            .handle_response(response, &promise, can_gc);
-    }
-}
-
-pub(crate) fn response_async<T: AsyncWGPUListener + DomObject + 'static>(
-    promise: &Rc<Promise>,
-    receiver: &T,
-) -> IpcSender<WebGPUResponse> {
-    let (action_sender, action_receiver) = ipc::channel().unwrap();
-    let task_source = receiver
-        .global()
-        .task_manager()
-        .dom_manipulation_task_source()
-        .to_sendable();
-    let mut trusted: Option<TrustedPromise> = Some(TrustedPromise::new(promise.clone()));
-    let trusted_receiver = Trusted::new(receiver);
-    ROUTER.add_typed_route(
-        action_receiver,
-        Box::new(move |message| {
-            let trusted = if let Some(trusted) = trusted.take() {
-                trusted
-            } else {
-                error!("WebGPU callback called twice!");
-                return;
-            };
-
-            let context = WGPUResponse {
-                trusted,
-                receiver: trusted_receiver.clone(),
-            };
-            task_source.queue(task!(process_webgpu_task: move|| {
-                context.response(message.unwrap(), CanGc::note());
-            }));
-        }),
-    );
-    action_sender
-}
-
 impl GPUMethods<crate::DomTypeHolder> for GPU {
     // https://gpuweb.github.io/gpuweb/#dom-gpu-requestadapter
     fn RequestAdapter(
@@ -111,7 +56,7 @@ impl GPUMethods<crate::DomTypeHolder> for GPU {
     ) -> Rc<Promise> {
         let global = &self.global();
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let sender = response_async(&promise, self);
+        let sender = route_promise(&promise, self);
         let power_preference = match options.powerPreference {
             Some(GPUPowerPreference::Low_power) => PowerPreference::LowPower,
             Some(GPUPowerPreference::High_performance) => PowerPreference::HighPerformance,
@@ -150,10 +95,15 @@ impl GPUMethods<crate::DomTypeHolder> for GPU {
     }
 }
 
-impl AsyncWGPUListener for GPU {
-    fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>, can_gc: CanGc) {
+impl RoutedPromiseListener<WebGPUAdapterResponse> for GPU {
+    fn handle_response(
+        &self,
+        response: WebGPUAdapterResponse,
+        promise: &Rc<Promise>,
+        can_gc: CanGc,
+    ) {
         match response {
-            WebGPUResponse::Adapter(Ok(adapter)) => {
+            Some(Ok(adapter)) => {
                 let adapter = GPUAdapter::new(
                     &self.global(),
                     adapter.channel,
@@ -170,15 +120,14 @@ impl AsyncWGPUListener for GPU {
                 );
                 promise.resolve_native(&adapter, can_gc);
             },
-            WebGPUResponse::Adapter(Err(e)) => {
+            Some(Err(e)) => {
                 warn!("Could not get GPUAdapter ({:?})", e);
                 promise.resolve_native(&None::<GPUAdapter>, can_gc);
             },
-            WebGPUResponse::None => {
+            None => {
                 warn!("Couldn't get a response, because WebGPU is disabled");
                 promise.resolve_native(&None::<GPUAdapter>, can_gc);
             },
-            _ => unreachable!("GPU received wrong WebGPUResponse"),
         }
     }
 }

components/script/dom/webgpu/gpuadapter.rs

@@ -8,7 +8,7 @@ use dom_struct::dom_struct;
 use js::jsapi::{Heap, JSObject};
 use webgpu::wgc::instance::RequestDeviceError;
 use webgpu::wgt::MemoryHints;
-use webgpu::{WebGPU, WebGPUAdapter, WebGPURequest, WebGPUResponse, wgt};
+use webgpu::{WebGPU, WebGPUAdapter, WebGPUDeviceResponse, WebGPURequest, wgt};
 
 use super::gpusupportedfeatures::GPUSupportedFeatures;
 use super::gpusupportedlimits::set_limit;
@@ -22,10 +22,10 @@ use crate::dom::bindings::str::DOMString;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
 use crate::dom::types::{GPUAdapterInfo, GPUSupportedLimits};
-use crate::dom::webgpu::gpu::{AsyncWGPUListener, response_async};
 use crate::dom::webgpu::gpudevice::GPUDevice;
 use crate::dom::webgpu::gpusupportedfeatures::gpu_to_wgt_feature;
 use crate::realms::InRealm;
+use crate::routed_promise::{RoutedPromiseListener, route_promise};
 use crate::script_runtime::CanGc;
 
 #[dom_struct]
@@ -116,7 +116,7 @@ impl GPUAdapterMethods<crate::DomTypeHolder> for GPUAdapter {
     ) -> Rc<Promise> {
         // Step 2
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let sender = response_async(&promise, self);
+        let sender = route_promise(&promise, self);
         let mut required_features = wgt::Features::empty();
         for &ext in descriptor.requiredFeatures.iter() {
             if let Some(feature) = gpu_to_wgt_feature(ext) {
@@ -205,10 +205,15 @@ impl GPUAdapterMethods<crate::DomTypeHolder> for GPUAdapter {
     }
 }
 
-impl AsyncWGPUListener for GPUAdapter {
-    fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>, can_gc: CanGc) {
+impl RoutedPromiseListener<WebGPUDeviceResponse> for GPUAdapter {
+    fn handle_response(
+        &self,
+        response: WebGPUDeviceResponse,
+        promise: &Rc<Promise>,
+        can_gc: CanGc,
+    ) {
         match response {
-            WebGPUResponse::Device((device_id, queue_id, Ok(descriptor))) => {
+            (device_id, queue_id, Ok(descriptor)) => {
                 let device = GPUDevice::new(
                     &self.global(),
                     self.channel.clone(),
@@ -224,16 +229,14 @@ impl AsyncWGPUListener for GPUAdapter {
                 self.global().add_gpu_device(&device);
                 promise.resolve_native(&device, can_gc);
             },
-            WebGPUResponse::Device((_, _, Err(RequestDeviceError::UnsupportedFeature(f)))) => {
-                promise.reject_error(
-                    Error::Type(RequestDeviceError::UnsupportedFeature(f).to_string()),
-                    can_gc,
-                )
-            },
-            WebGPUResponse::Device((_, _, Err(RequestDeviceError::LimitsExceeded(_)))) => {
+            (_, _, Err(RequestDeviceError::UnsupportedFeature(f))) => promise.reject_error(
+                Error::Type(RequestDeviceError::UnsupportedFeature(f).to_string()),
+                can_gc,
+            ),
+            (_, _, Err(RequestDeviceError::LimitsExceeded(_))) => {
                 promise.reject_error(Error::Operation, can_gc)
             },
-            WebGPUResponse::Device((device_id, queue_id, Err(e))) => {
+            (device_id, queue_id, Err(e)) => {
                 let device = GPUDevice::new(
                     &self.global(),
                     self.channel.clone(),
@@ -249,8 +252,6 @@ impl AsyncWGPUListener for GPUAdapter {
                 device.lose(GPUDeviceLostReason::Unknown, e.to_string(), can_gc);
                 promise.resolve_native(&device, can_gc);
             },
-            WebGPUResponse::None => unreachable!("Failed to get a response for RequestDevice"),
-            _ => unreachable!("GPUAdapter received wrong WebGPUResponse"),
         }
     }
 }

components/script/dom/webgpu/gpubuffer.rs

@@ -10,7 +10,8 @@ use dom_struct::dom_struct;
 use ipc_channel::ipc::IpcSharedMemory;
 use js::typedarray::ArrayBuffer;
 use webgpu::wgc::device::HostMap;
-use webgpu::{Mapping, WebGPU, WebGPUBuffer, WebGPURequest, WebGPUResponse, wgt};
+use webgpu::{Mapping, WebGPU, WebGPUBuffer, WebGPURequest, wgc, wgt};
+use wgc::resource::BufferAccessError;
 
 use crate::conversions::Convert;
 use crate::dom::bindings::buffer_source::DataBlock;
@@ -25,9 +26,9 @@ use crate::dom::bindings::root::{Dom, DomRoot};
 use crate::dom::bindings::str::USVString;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
-use crate::dom::webgpu::gpu::{AsyncWGPUListener, response_async};
 use crate::dom::webgpu::gpudevice::GPUDevice;
 use crate::realms::InRealm;
+use crate::routed_promise::{RoutedPromiseListener, route_promise};
 use crate::script_runtime::{CanGc, JSContext};
 
 #[derive(JSTraceable, MallocSizeOf)]
@@ -270,7 +271,7 @@ impl GPUBufferMethods<crate::DomTypeHolder> for GPUBuffer {
             },
         };
 
-        let sender = response_async(&promise, self);
+        let sender = route_promise(&promise, self);
         if let Err(e) = self.channel.0.send(WebGPURequest::BufferMapAsync {
             sender,
             buffer_id: self.buffer.0,
@@ -419,15 +420,16 @@ impl GPUBuffer {
     }
 }
 
-impl AsyncWGPUListener for GPUBuffer {
-    #[allow(unsafe_code)]
-    fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>, can_gc: CanGc) {
+impl RoutedPromiseListener<Result<Mapping, BufferAccessError>> for GPUBuffer {
+    fn handle_response(
+        &self,
+        response: Result<Mapping, BufferAccessError>,
+        promise: &Rc<Promise>,
+        can_gc: CanGc,
+    ) {
         match response {
-            WebGPUResponse::BufferMapAsync(Ok(mapping)) => {
-                self.map_success(promise, mapping, can_gc)
-            },
-            WebGPUResponse::BufferMapAsync(Err(_)) => self.map_failure(promise, can_gc),
-            _ => unreachable!("Wrong response received on AsyncWGPUListener for GPUBuffer"),
+            Ok(mapping) => self.map_success(promise, mapping, can_gc),
+            Err(_) => self.map_failure(promise, can_gc),
         }
     }
 }

components/script/dom/webgpu/gpucomputepipeline.rs

@@ -5,7 +5,10 @@
 use dom_struct::dom_struct;
 use ipc_channel::ipc::IpcSender;
 use webgpu::wgc::pipeline::ComputePipelineDescriptor;
-use webgpu::{WebGPU, WebGPUBindGroupLayout, WebGPUComputePipeline, WebGPURequest, WebGPUResponse};
+use webgpu::{
+    WebGPU, WebGPUBindGroupLayout, WebGPUComputePipeline, WebGPUComputePipelineResponse,
+    WebGPURequest,
+};
 
 use crate::conversions::Convert;
 use crate::dom::bindings::cell::DomRefCell;
@@ -76,7 +79,7 @@ impl GPUComputePipeline {
     pub(crate) fn create(
         device: &GPUDevice,
         descriptor: &GPUComputePipelineDescriptor,
-        async_sender: Option<IpcSender<WebGPUResponse>>,
+        async_sender: Option<IpcSender<WebGPUComputePipelineResponse>>,
     ) -> WebGPUComputePipeline {
         let compute_pipeline_id = device.global().wgpu_id_hub().create_compute_pipeline_id();
 

components/script/dom/webgpu/gpudevice.rs

@@ -15,11 +15,11 @@ use webgpu::wgc::pipeline as wgpu_pipe;
 use webgpu::wgc::pipeline::RenderPipelineDescriptor;
 use webgpu::wgt::TextureFormat;
 use webgpu::{
-    PopError, WebGPU, WebGPUComputePipeline, WebGPURenderPipeline, WebGPURequest, WebGPUResponse,
-    wgt,
+    PopError, WebGPU, WebGPUComputePipeline, WebGPUComputePipelineResponse,
+    WebGPUPoppedErrorScopeResponse, WebGPURenderPipeline, WebGPURenderPipelineResponse,
+    WebGPURequest, wgt,
 };
 
-use super::gpu::AsyncWGPUListener;
 use super::gpudevicelostinfo::GPUDeviceLostInfo;
 use super::gpuerror::AsWebGpu;
 use super::gpupipelineerror::GPUPipelineError;
@@ -46,7 +46,6 @@ use crate::dom::eventtarget::EventTarget;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
 use crate::dom::types::GPUError;
-use crate::dom::webgpu::gpu::response_async;
 use crate::dom::webgpu::gpuadapter::GPUAdapter;
 use crate::dom::webgpu::gpubindgroup::GPUBindGroup;
 use crate::dom::webgpu::gpubindgrouplayout::GPUBindGroupLayout;
@@ -63,6 +62,7 @@ use crate::dom::webgpu::gpusupportedfeatures::GPUSupportedFeatures;
 use crate::dom::webgpu::gputexture::GPUTexture;
 use crate::dom::webgpu::gpuuncapturederrorevent::GPUUncapturedErrorEvent;
 use crate::realms::InRealm;
+use crate::routed_promise::{RoutedPromiseListener, route_promise};
 use crate::script_runtime::CanGc;
 
 #[dom_struct]
@@ -469,7 +469,7 @@ impl GPUDeviceMethods<crate::DomTypeHolder> for GPUDevice {
         can_gc: CanGc,
     ) -> Rc<Promise> {
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let sender = response_async(&promise, self);
+        let sender = route_promise(&promise, self);
         GPUComputePipeline::create(self, descriptor, Some(sender));
         promise
     }
@@ -517,7 +517,7 @@ impl GPUDeviceMethods<crate::DomTypeHolder> for GPUDevice {
     ) -> Fallible<Rc<Promise>> {
         let (implicit_ids, desc) = self.parse_render_pipeline(descriptor)?;
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let sender = response_async(&promise, self);
+        let sender = route_promise(&promise, self);
         GPURenderPipeline::create(self, implicit_ids, desc, Some(sender))?;
         Ok(promise)
     }
@@ -548,7 +548,7 @@ impl GPUDeviceMethods<crate::DomTypeHolder> for GPUDevice {
     /// <https://gpuweb.github.io/gpuweb/#dom-gpudevice-poperrorscope>
     fn PopErrorScope(&self, comp: InRealm, can_gc: CanGc) -> Rc<Promise> {
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let sender = response_async(&promise, self);
+        let sender = route_promise(&promise, self);
         if self
             .channel
             .0
@@ -582,82 +582,104 @@ impl GPUDeviceMethods<crate::DomTypeHolder> for GPUDevice {
     }
 }
 
-impl AsyncWGPUListener for GPUDevice {
-    fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>, can_gc: CanGc) {
+impl RoutedPromiseListener<WebGPUPoppedErrorScopeResponse> for GPUDevice {
+    fn handle_response(
+        &self,
+        response: WebGPUPoppedErrorScopeResponse,
+        promise: &Rc<Promise>,
+        can_gc: CanGc,
+    ) {
         match response {
-            WebGPUResponse::PoppedErrorScope(result) => match result {
-                Ok(None) | Err(PopError::Lost) => {
-                    promise.resolve_native(&None::<Option<GPUError>>, can_gc)
-                },
-                Err(PopError::Empty) => promise.reject_error(Error::Operation, can_gc),
-                Ok(Some(error)) => {
-                    let error = GPUError::from_error(&self.global(), error, can_gc);
-                    promise.resolve_native(&error, can_gc);
-                },
+            Ok(None) | Err(PopError::Lost) => {
+                promise.resolve_native(&None::<Option<GPUError>>, can_gc)
             },
-            WebGPUResponse::ComputePipeline(result) => match result {
-                Ok(pipeline) => promise.resolve_native(
-                    &GPUComputePipeline::new(
-                        &self.global(),
-                        WebGPUComputePipeline(pipeline.id),
-                        pipeline.label.into(),
-                        self,
-                        can_gc,
-                    ),
+            Err(PopError::Empty) => promise.reject_error(Error::Operation, can_gc),
+            Ok(Some(error)) => {
+                let error = GPUError::from_error(&self.global(), error, can_gc);
+                promise.resolve_native(&error, can_gc);
+            },
+        }
+    }
+}
+
+impl RoutedPromiseListener<WebGPUComputePipelineResponse> for GPUDevice {
+    fn handle_response(
+        &self,
+        response: WebGPUComputePipelineResponse,
+        promise: &Rc<Promise>,
+        can_gc: CanGc,
+    ) {
+        match response {
+            Ok(pipeline) => promise.resolve_native(
+                &GPUComputePipeline::new(
+                    &self.global(),
+                    WebGPUComputePipeline(pipeline.id),
+                    pipeline.label.into(),
+                    self,
                     can_gc,
                 ),
-                Err(webgpu::Error::Validation(msg)) => promise.reject_native(
+                can_gc,
+            ),
+            Err(webgpu::Error::Validation(msg)) => promise.reject_native(
+                &GPUPipelineError::new(
+                    &self.global(),
+                    msg.into(),
+                    GPUPipelineErrorReason::Validation,
+                    can_gc,
+                ),
+                can_gc,
+            ),
+            Err(webgpu::Error::OutOfMemory(msg) | webgpu::Error::Internal(msg)) => promise
+                .reject_native(
                     &GPUPipelineError::new(
                         &self.global(),
                         msg.into(),
-                        GPUPipelineErrorReason::Validation,
+                        GPUPipelineErrorReason::Internal,
                         can_gc,
                     ),
                     can_gc,
                 ),
-                Err(webgpu::Error::OutOfMemory(msg) | webgpu::Error::Internal(msg)) => promise
-                    .reject_native(
-                        &GPUPipelineError::new(
-                            &self.global(),
-                            msg.into(),
-                            GPUPipelineErrorReason::Internal,
-                            can_gc,
-                        ),
-                        can_gc,
-                    ),
-            },
-            WebGPUResponse::RenderPipeline(result) => match result {
-                Ok(pipeline) => promise.resolve_native(
-                    &GPURenderPipeline::new(
-                        &self.global(),
-                        WebGPURenderPipeline(pipeline.id),
-                        pipeline.label.into(),
-                        self,
-                        can_gc,
-                    ),
+        }
+    }
+}
+
+impl RoutedPromiseListener<WebGPURenderPipelineResponse> for GPUDevice {
+    fn handle_response(
+        &self,
+        response: WebGPURenderPipelineResponse,
+        promise: &Rc<Promise>,
+        can_gc: CanGc,
+    ) {
+        match response {
+            Ok(pipeline) => promise.resolve_native(
+                &GPURenderPipeline::new(
+                    &self.global(),
+                    WebGPURenderPipeline(pipeline.id),
+                    pipeline.label.into(),
+                    self,
                     can_gc,
                 ),
-                Err(webgpu::Error::Validation(msg)) => promise.reject_native(
+                can_gc,
+            ),
+            Err(webgpu::Error::Validation(msg)) => promise.reject_native(
+                &GPUPipelineError::new(
+                    &self.global(),
+                    msg.into(),
+                    GPUPipelineErrorReason::Validation,
+                    can_gc,
+                ),
+                can_gc,
+            ),
+            Err(webgpu::Error::OutOfMemory(msg) | webgpu::Error::Internal(msg)) => promise
+                .reject_native(
                     &GPUPipelineError::new(
                         &self.global(),
                         msg.into(),
-                        GPUPipelineErrorReason::Validation,
+                        GPUPipelineErrorReason::Internal,
                         can_gc,
                     ),
                     can_gc,
                 ),
-                Err(webgpu::Error::OutOfMemory(msg) | webgpu::Error::Internal(msg)) => promise
-                    .reject_native(
-                        &GPUPipelineError::new(
-                            &self.global(),
-                            msg.into(),
-                            GPUPipelineErrorReason::Internal,
-                            can_gc,
-                        ),
-                        can_gc,
-                    ),
-            },
-            _ => unreachable!("Wrong response received on AsyncWGPUListener for GPUDevice"),
         }
     }
 }

components/script/dom/webgpu/gpuqueue.rs

@@ -6,9 +6,8 @@ use std::rc::Rc;
 
 use dom_struct::dom_struct;
 use ipc_channel::ipc::IpcSharedMemory;
-use webgpu::{WebGPU, WebGPUQueue, WebGPURequest, WebGPUResponse, wgt};
+use webgpu::{WebGPU, WebGPUQueue, WebGPURequest, wgt};
 
-use super::gpu::{AsyncWGPUListener, response_async};
 use crate::conversions::{Convert, TryConvert};
 use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::codegen::Bindings::WebGPUBinding::{
@@ -24,6 +23,7 @@ use crate::dom::promise::Promise;
 use crate::dom::webgpu::gpubuffer::GPUBuffer;
 use crate::dom::webgpu::gpucommandbuffer::GPUCommandBuffer;
 use crate::dom::webgpu::gpudevice::GPUDevice;
+use crate::routed_promise::{RoutedPromiseListener, route_promise};
 use crate::script_runtime::CanGc;
 
 #[dom_struct]
@@ -200,7 +200,7 @@ impl GPUQueueMethods<crate::DomTypeHolder> for GPUQueue {
     fn OnSubmittedWorkDone(&self, can_gc: CanGc) -> Rc<Promise> {
         let global = self.global();
         let promise = Promise::new(&global, can_gc);
-        let sender = response_async(&promise, self);
+        let sender = route_promise(&promise, self);
         if let Err(e) = self
             .channel
             .0
@@ -215,21 +215,8 @@ impl GPUQueueMethods<crate::DomTypeHolder> for GPUQueue {
     }
 }
 
-impl AsyncWGPUListener for GPUQueue {
-    fn handle_response(
-        &self,
-        response: webgpu::WebGPUResponse,
-        promise: &Rc<Promise>,
-        can_gc: CanGc,
-    ) {
-        match response {
-            WebGPUResponse::SubmittedWorkDone => {
-                promise.resolve_native(&(), can_gc);
-            },
-            _ => {
-                warn!("GPUQueue received wrong WebGPUResponse");
-                promise.reject_error(Error::Operation, can_gc);
-            },
-        }
+impl RoutedPromiseListener<()> for GPUQueue {
+    fn handle_response(&self, _response: (), promise: &Rc<Promise>, can_gc: CanGc) {
+        promise.resolve_native(&(), can_gc);
     }
 }

components/script/dom/webgpu/gpurenderpipeline.rs

@@ -5,7 +5,10 @@
 use dom_struct::dom_struct;
 use ipc_channel::ipc::IpcSender;
 use webgpu::wgc::pipeline::RenderPipelineDescriptor;
-use webgpu::{WebGPU, WebGPUBindGroupLayout, WebGPURenderPipeline, WebGPURequest, WebGPUResponse};
+use webgpu::{
+    WebGPU, WebGPUBindGroupLayout, WebGPURenderPipeline, WebGPURenderPipelineResponse,
+    WebGPURequest,
+};
 
 use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::codegen::Bindings::WebGPUBinding::GPURenderPipelineMethods;
@@ -74,7 +77,7 @@ impl GPURenderPipeline {
         device: &GPUDevice,
         pipeline_layout: PipelineLayout,
         descriptor: RenderPipelineDescriptor<'static>,
-        async_sender: Option<IpcSender<WebGPUResponse>>,
+        async_sender: Option<IpcSender<WebGPURenderPipelineResponse>>,
     ) -> Fallible<WebGPURenderPipeline> {
         let render_pipeline_id = device.global().wgpu_id_hub().create_render_pipeline_id();
 

components/script/dom/webgpu/gpushadermodule.rs

@@ -5,9 +5,8 @@
 use std::rc::Rc;
 
 use dom_struct::dom_struct;
-use webgpu::{WebGPU, WebGPURequest, WebGPUResponse, WebGPUShaderModule};
+use webgpu::{ShaderCompilationInfo, WebGPU, WebGPURequest, WebGPUShaderModule};
 
-use super::gpu::AsyncWGPUListener;
 use super::gpucompilationinfo::GPUCompilationInfo;
 use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::codegen::Bindings::WebGPUBinding::{
@@ -20,8 +19,8 @@ use crate::dom::bindings::trace::RootedTraceableBox;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
 use crate::dom::types::GPUDevice;
-use crate::dom::webgpu::gpu::response_async;
 use crate::realms::InRealm;
+use crate::routed_promise::{RoutedPromiseListener, route_promise};
 use crate::script_runtime::CanGc;
 
 #[dom_struct]
@@ -96,7 +95,7 @@ impl GPUShaderModule {
             promise.clone(),
             can_gc,
         );
-        let sender = response_async(&promise, &*shader_module);
+        let sender = route_promise(&promise, &*shader_module);
         device
             .channel()
             .0
@@ -129,15 +128,15 @@ impl GPUShaderModuleMethods<crate::DomTypeHolder> for GPUShaderModule {
     }
 }
 
-impl AsyncWGPUListener for GPUShaderModule {
-    fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>, can_gc: CanGc) {
-        match response {
-            WebGPUResponse::CompilationInfo(info) => {
-                let info = GPUCompilationInfo::from(&self.global(), info, can_gc);
-                promise.resolve_native(&info, can_gc);
-            },
-            _ => unreachable!("Wrong response received on AsyncWGPUListener for GPUShaderModule"),
-        }
+impl RoutedPromiseListener<Option<ShaderCompilationInfo>> for GPUShaderModule {
+    fn handle_response(
+        &self,
+        response: Option<ShaderCompilationInfo>,
+        promise: &Rc<Promise>,
+        can_gc: CanGc,
+    ) {
+        let info = GPUCompilationInfo::from(&self.global(), response, can_gc);
+        promise.resolve_native(&info, can_gc);
     }
 }
 

components/script/routed_promise.rs

@@ -14,20 +14,23 @@ use crate::dom::bindings::reflector::{DomGlobal, DomObject};
 use crate::dom::promise::Promise;
 use crate::script_runtime::CanGc;
 
-pub(crate) trait RoutedPromiseListener {
-    type Response: Serialize + DeserializeOwned + Send;
-
-    fn handle_response(&self, response: Self::Response, promise: &Rc<Promise>, can_gc: CanGc);
+pub(crate) trait RoutedPromiseListener<R: Serialize + DeserializeOwned + Send> {
+    fn handle_response(&self, response: R, promise: &Rc<Promise>, can_gc: CanGc);
 }
 
-pub(crate) struct RoutedPromiseContext<T: RoutedPromiseListener + DomObject> {
+pub(crate) struct RoutedPromiseContext<
+    R: Serialize + DeserializeOwned + Send,
+    T: RoutedPromiseListener<R> + DomObject,
+> {
     trusted: TrustedPromise,
     receiver: Trusted<T>,
+    _phantom: std::marker::PhantomData<R>,
 }
 
-impl<T: RoutedPromiseListener + DomObject> RoutedPromiseContext<T> {
-    #[cfg_attr(crown, allow(crown::unrooted_must_root))]
-    fn response(self, response: T::Response, can_gc: CanGc) {
+impl<R: Serialize + DeserializeOwned + Send, T: RoutedPromiseListener<R> + DomObject>
+    RoutedPromiseContext<R, T>
+{
+    fn response(self, response: R, can_gc: CanGc) {
         let promise = self.trusted.root();
         self.receiver
             .root()
@@ -35,10 +38,13 @@ impl<T: RoutedPromiseListener + DomObject> RoutedPromiseContext<T> {
     }
 }
 
-pub(crate) fn route_promise<T: RoutedPromiseListener + DomObject + 'static>(
+pub(crate) fn route_promise<
+    R: Serialize + DeserializeOwned + Send + 'static,
+    T: RoutedPromiseListener<R> + DomObject + 'static,
+>(
     promise: &Rc<Promise>,
     receiver: &T,
-) -> IpcSender<T::Response> {
+) -> IpcSender<R> {
     let (action_sender, action_receiver) = ipc::channel().unwrap();
     let task_source = receiver
         .global()
@@ -60,6 +66,7 @@ pub(crate) fn route_promise<T: RoutedPromiseListener + DomObject + 'static>(
             let context = RoutedPromiseContext {
                 trusted,
                 receiver: trusted_receiver.clone(),
+                _phantom: Default::default(),
             };
             task_source.queue(task!(routed_promise_task: move|| {
                 context.response(message.unwrap(), CanGc::note());