diff --git a/components/constellation/constellation.rs b/components/constellation/constellation.rs index feb02548338..a4d276b196e 100644 --- a/components/constellation/constellation.rs +++ b/components/constellation/constellation.rs @@ -2063,7 +2063,11 @@ where }; match request { FromScriptMsg::RequestAdapter(response_sender, options, ids) => match webgpu_chan { - None => warn!("Failed to send request adapter message, missing WebGPU channel"), + None => { + if let Err(e) = response_sender.send(None) { + return warn!("Failed to send request adapter message: {}", e); + } + }, Some(webgpu_chan) => { let adapter_request = WebGPURequest::RequestAdapter { sender: response_sender, diff --git a/components/script/dom/gpu.rs b/components/script/dom/gpu.rs index af8620c3a8c..d3babad3850 100644 --- a/components/script/dom/gpu.rs +++ b/components/script/dom/gpu.rs @@ -45,7 +45,7 @@ impl GPU { } pub trait AsyncWGPUListener { - fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc); + fn handle_response(&self, response: Option, promise: &Rc); } struct WGPUResponse { @@ -55,7 +55,7 @@ struct WGPUResponse { impl WGPUResponse { #[allow(crown::unrooted_must_root)] - fn response(self, response: WebGPUResponseResult) { + fn response(self, response: Option) { let promise = self.trusted.root(); self.receiver.root().handle_response(response, &promise); } @@ -64,13 +64,13 @@ impl WGPUResponse { pub fn response_async( promise: &Rc, receiver: &T, -) -> IpcSender { +) -> IpcSender> { let (action_sender, action_receiver) = ipc::channel().unwrap(); let task_source = receiver.global().dom_manipulation_task_source(); let canceller = receiver .global() .task_canceller(TaskSourceName::DOMManipulation); - let mut trusted = Some(TrustedPromise::new(promise.clone())); + let mut trusted: Option = Some(TrustedPromise::new(promise.clone())); let trusted_receiver = Trusted::new(receiver); ROUTER.add_route( action_receiver.to_opaque(), @@ -139,39 +139,42 @@ impl GPUMethods for GPU { } impl AsyncWGPUListener for GPU { - fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc) { + fn handle_response(&self, response: Option, promise: &Rc) { match response { - Ok(WebGPUResponse::RequestAdapter { - adapter_info, - adapter_id, - features, - limits, - channel, - }) => { - let adapter = GPUAdapter::new( - &self.global(), - channel, - DOMString::from(format!( - "{} ({:?})", - adapter_info.name, - adapter_id.0.backend() - )), - Heap::default(), - features, - limits, + Some(response) => match response { + Ok(WebGPUResponse::RequestAdapter { adapter_info, adapter_id, - ); - promise.resolve_native(&adapter); + features, + limits, + channel, + }) => { + let adapter = GPUAdapter::new( + &self.global(), + channel, + DOMString::from(format!( + "{} ({:?})", + adapter_info.name, + adapter_id.0.backend() + )), + Heap::default(), + features, + limits, + adapter_info, + adapter_id, + ); + promise.resolve_native(&adapter); + }, + Err(e) => { + warn!("Could not get GPUAdapter ({:?})", e); + promise.resolve_native(&None::); + }, + Ok(_) => unreachable!("GPU received wrong WebGPUResponse"), }, - Err(e) => { - warn!("Could not get GPUAdapter ({:?})", e); + None => { + warn!("Couldn't get a response, because WebGPU is disabled"); promise.resolve_native(&None::); }, - _ => { - warn!("GPU received wrong WebGPUResponse"); - promise.reject_error(Error::Operation); - }, } } } diff --git a/components/script/dom/gpuadapter.rs b/components/script/dom/gpuadapter.rs index dd5b31e1be2..03170efb8e2 100644 --- a/components/script/dom/gpuadapter.rs +++ b/components/script/dom/gpuadapter.rs @@ -237,35 +237,35 @@ impl GPUAdapterMethods for GPUAdapter { } impl AsyncWGPUListener for GPUAdapter { - fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc) { + fn handle_response(&self, response: Option, promise: &Rc) { match response { - Ok(WebGPUResponse::RequestDevice { - device_id, - queue_id, - descriptor, - }) => { - let device = GPUDevice::new( - &self.global(), - self.channel.clone(), - &self, - Heap::default(), - descriptor.features, - descriptor.limits, + Some(response) => match response { + Ok(WebGPUResponse::RequestDevice { device_id, queue_id, - descriptor.label.unwrap_or_default(), - ); - self.global().add_gpu_device(&device); - promise.resolve_native(&device); - }, - Err(e) => { - warn!("Could not get GPUDevice({:?})", e); - promise.reject_error(Error::Operation); - }, - _ => { - warn!("GPUAdapter received wrong WebGPUResponse"); - promise.reject_error(Error::Operation); + descriptor, + }) => { + let device = GPUDevice::new( + &self.global(), + self.channel.clone(), + &self, + Heap::default(), + descriptor.features, + descriptor.limits, + device_id, + queue_id, + descriptor.label.unwrap_or_default(), + ); + self.global().add_gpu_device(&device); + promise.resolve_native(&device); + }, + Err(e) => { + warn!("Could not get GPUDevice({:?})", e); + promise.reject_error(Error::Operation); + }, + Ok(_) => unreachable!("GPUAdapter received wrong WebGPUResponse"), }, + None => unreachable!("Failed to get a response for RequestDevice"), } } } diff --git a/components/script/dom/gpubuffer.rs b/components/script/dom/gpubuffer.rs index 8f2b9b0f988..8a97bf3cace 100644 --- a/components/script/dom/gpubuffer.rs +++ b/components/script/dom/gpubuffer.rs @@ -346,27 +346,27 @@ impl GPUBufferMethods for GPUBuffer { impl AsyncWGPUListener for GPUBuffer { #[allow(unsafe_code)] - fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc) { + fn handle_response(&self, response: Option, promise: &Rc) { match response { - Ok(WebGPUResponse::BufferMapAsync(bytes)) => { - *self - .map_info - .borrow_mut() - .as_mut() - .unwrap() - .mapping - .borrow_mut() = bytes.to_vec(); - promise.resolve_native(&()); - self.state.set(GPUBufferState::Mapped); - }, - Err(e) => { - warn!("Could not map buffer({:?})", e); - promise.reject_error(Error::Abort); - }, - _ => { - warn!("GPUBuffer received wrong WebGPUResponse"); - promise.reject_error(Error::Operation); + Some(response) => match response { + Ok(WebGPUResponse::BufferMapAsync(bytes)) => { + *self + .map_info + .borrow_mut() + .as_mut() + .unwrap() + .mapping + .borrow_mut() = bytes.to_vec(); + promise.resolve_native(&()); + self.state.set(GPUBufferState::Mapped); + }, + Err(e) => { + warn!("Could not map buffer({:?})", e); + promise.reject_error(Error::Abort); + }, + Ok(_) => unreachable!("GPUBuffer received wrong WebGPUResponse"), }, + None => unreachable!("Failed to get a response for BufferMapAsync"), } *self.map_promise.borrow_mut() = None; if let Err(e) = self diff --git a/components/shared/script/script_msg.rs b/components/shared/script/script_msg.rs index 614362575b3..7612d15c16a 100644 --- a/components/shared/script/script_msg.rs +++ b/components/shared/script/script_msg.rs @@ -258,7 +258,7 @@ pub enum ScriptMsg { MediaSessionEvent(PipelineId, MediaSessionEvent), /// Create a WebGPU Adapter instance RequestAdapter( - IpcSender, + IpcSender>, wgpu::instance::RequestAdapterOptions, SmallVec<[wgpu::id::AdapterId; 4]>, ), diff --git a/components/webgpu/lib.rs b/components/webgpu/lib.rs index 77f21dd0c52..7f95db0850f 100644 --- a/components/webgpu/lib.rs +++ b/components/webgpu/lib.rs @@ -75,7 +75,7 @@ pub type WebGPUResponseResult = Result; #[derive(Debug, Deserialize, Serialize)] pub enum WebGPURequest { BufferMapAsync { - sender: IpcSender, + sender: IpcSender>, buffer_id: id::BufferId, device_id: id::DeviceId, host_map: HostMap, @@ -202,12 +202,12 @@ pub enum WebGPURequest { device_id: id::DeviceId, }, RequestAdapter { - sender: IpcSender, + sender: IpcSender>, options: RequestAdapterOptions, ids: SmallVec<[id::AdapterId; 4]>, }, RequestDevice { - sender: IpcSender, + sender: IpcSender>, adapter_id: WebGPUAdapter, descriptor: wgt::DeviceDescriptor>, device_id: id::DeviceId, @@ -340,7 +340,7 @@ struct WGPU<'a> { // Track invalid adapters https://gpuweb.github.io/gpuweb/#invalid _invalid_adapters: Vec, // Buffers with pending mapping - buffer_maps: HashMap>>, + buffer_maps: HashMap>>>, // Presentation Buffers with pending mapping present_buffer_maps: HashMap, WebGPURequest)>>>, @@ -423,7 +423,7 @@ impl<'a> WGPU<'a> { userdata: *mut u8, ) { let info = Rc::from_raw( - userdata as *const BufferMapInfo, + userdata as *const BufferMapInfo>, ); let msg = match status { BufferMapAsyncStatus::Success => { @@ -442,7 +442,7 @@ impl<'a> WGPU<'a> { Err(String::from("Failed to map Buffer")) }, }; - if let Err(e) = info.sender.send(msg) { + if let Err(e) = info.sender.send(Some(msg)) { warn!("Could not send BufferMapAsync Response ({})", e); } } @@ -461,7 +461,7 @@ impl<'a> WGPU<'a> { let global = &self.global; let result = gfx_select!(buffer_id => global.buffer_map_async(buffer_id, map_range, operation)); if let Err(ref e) = result { - if let Err(w) = sender.send(Err(format!("{:?}", e))) { + if let Err(w) = sender.send(Some(Err(format!("{:?}", e)))) { warn!("Failed to send BufferMapAsync Response ({:?})", w); } } @@ -879,7 +879,7 @@ impl<'a> WGPU<'a> { ) { Ok(id) => id, Err(w) => { - if let Err(e) = sender.send(Err(format!("{:?}", w))) { + if let Err(e) = sender.send(Some(Err(format!("{:?}", w)))) { warn!( "Failed to send response to WebGPURequest::RequestAdapter ({})", e @@ -898,13 +898,13 @@ impl<'a> WGPU<'a> { gfx_select!(adapter_id => global.adapter_limits(adapter_id)).unwrap(); let features = gfx_select!(adapter_id => global.adapter_features(adapter_id)).unwrap(); - if let Err(e) = sender.send(Ok(WebGPUResponse::RequestAdapter { + if let Err(e) = sender.send(Some(Ok(WebGPUResponse::RequestAdapter { adapter_info: info, adapter_id: adapter, features, limits, channel: WebGPU(self.sender.clone()), - })) { + }))) { warn!( "Failed to send response to WebGPURequest::RequestAdapter ({})", e @@ -934,7 +934,7 @@ impl<'a> WGPU<'a> { ) { Ok(id) => id, Err(e) => { - if let Err(w) = sender.send(Err(format!("{:?}", e))) { + if let Err(w) = sender.send(Some(Err(format!("{:?}", e)))) { warn!( "Failed to send response to WebGPURequest::RequestDevice ({})", w @@ -948,11 +948,11 @@ impl<'a> WGPU<'a> { // since wgpu-core uses the same id for the device and the queue let queue = WebGPUQueue(id); self.devices.insert(device, pipeline_id); - if let Err(e) = sender.send(Ok(WebGPUResponse::RequestDevice { + if let Err(e) = sender.send(Some(Ok(WebGPUResponse::RequestDevice { device_id: device, queue_id: queue, descriptor, - })) { + }))) { warn!( "Failed to send response to WebGPURequest::RequestDevice ({})", e