Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 20:50:07 +01:00
Code Issues Projects Releases Packages Wiki Activity

Fix failed request for adapter when not available (#31002)

Browse source 
Signed-off-by: Bentaimia Haddadi <haddadi.taym@gmail.com>
This commit is contained in:
Taym Haddadi 2024-01-09 10:12:53 +01:00 • committed by GitHub
parent dd0149d953
commit fddc4a430f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 97 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

65
components/script/dom/gpu.rs
View file

@ -45,7 +45,7 @@ impl GPU {
}
pub trait AsyncWGPUListener {
fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc<Promise>);
fn handle_response(&self, response: Option<WebGPUResponseResult>, promise: &Rc<Promise>);
}
struct WGPUResponse<T: AsyncWGPUListener + DomObject> {
@ -55,7 +55,7 @@ struct WGPUResponse<T: AsyncWGPUListener + DomObject> {
impl<T: AsyncWGPUListener + DomObject> WGPUResponse<T> {
#[allow(crown::unrooted_must_root)]
fn response(self, response: WebGPUResponseResult) {
fn response(self, response: Option<WebGPUResponseResult>) {
let promise = self.trusted.root();
self.receiver.root().handle_response(response, &promise);
}
@ -64,13 +64,13 @@ impl<T: AsyncWGPUListener + DomObject> WGPUResponse<T> {
pub fn response_async<T: AsyncWGPUListener + DomObject + 'static>(
promise: &Rc<Promise>,
receiver: &T,
) -> IpcSender<WebGPUResponseResult> {
) -> IpcSender<Option<WebGPUResponseResult>> {
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<TrustedPromise> = 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<Promise>) {
fn handle_response(&self, response: Option<WebGPUResponseResult>, promise: &Rc<Promise>) {
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::<GPUAdapter>);
},
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::<GPUAdapter>);
},
_ => {
warn!("GPU received wrong WebGPUResponse");
promise.reject_error(Error::Operation);
},
}
}
}

50
components/script/dom/gpuadapter.rs
View file

@ -237,35 +237,35 @@ impl GPUAdapterMethods for GPUAdapter {
}
impl AsyncWGPUListener for GPUAdapter {
fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc<Promise>) {
fn handle_response(&self, response: Option<WebGPUResponseResult>, promise: &Rc<Promise>) {
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"),
}
}
}

38
components/script/dom/gpubuffer.rs
View file

@ -346,27 +346,27 @@ impl GPUBufferMethods for GPUBuffer {
impl AsyncWGPUListener for GPUBuffer {
#[allow(unsafe_code)]
fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc<Promise>) {
fn handle_response(&self, response: Option<WebGPUResponseResult>, promise: &Rc<Promise>) {
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