chore(ext/webgpu): clean up buffer_get_map_async (#24087)

1 files changed, 33 insertions, 42 deletions

diff --git a/ext/webgpu/buffer.rs b/ext/webgpu/buffer.rs
index 2887f3812..c6cd6f0a7 100644
--- a/ext/webgpu/buffer.rs
+++ b/ext/webgpu/buffer.rs
@@ -2,7 +2,6 @@
 
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
-use deno_core::futures::channel::oneshot;
 use deno_core::op2;
 use deno_core::OpState;
 use deno_core::Resource;
@@ -10,8 +9,9 @@ use deno_core::ResourceId;
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::rc::Rc;
+use std::sync::Arc;
+use std::sync::Mutex;
 use std::time::Duration;
-use wgpu_core::resource::BufferAccessResult;
 
 use super::error::DomExceptionOperationError;
 use super::error::WebGpuResult;
@@ -78,9 +78,8 @@ pub async fn op_webgpu_buffer_get_map_async(
   #[number] offset: u64,
   #[number] size: u64,
 ) -> Result<WebGpuResult, AnyError> {
-  let (sender, receiver) = oneshot::channel::<BufferAccessResult>();
-
   let device;
+  let done = Arc::new(Mutex::new(None));
   {
     let state_ = state.borrow();
     let instance = state_.borrow::<super::Instance>();
@@ -92,56 +91,48 @@ pub async fn op_webgpu_buffer_get_map_async(
       .get::<super::WebGpuDevice>(device_rid)?;
     device = device_resource.1;
 
+    let done_ = done.clone();
     let callback = Box::new(move |status| {
-      sender.send(status).unwrap();
+      *done_.lock().unwrap() = Some(status);
     });
 
-    // TODO(lucacasonato): error handling
     let maybe_err = gfx_select!(buffer => instance.buffer_map_async(
-            buffer,
-            offset,
-            Some(size),
-            wgpu_core::resource::BufferMapOperation {
-                host: match mode {
-                    1 => wgpu_core::device::HostMap::Read,
-                    2 => wgpu_core::device::HostMap::Write,
-                    _ => unreachable!(),
-                },
-                callback: Some(wgpu_core::resource::BufferMapCallback::from_rust(callback)),
-            }
-        ))
-        .err();
+      buffer,
+      offset,
+      Some(size),
+      wgpu_core::resource::BufferMapOperation {
+        host: match mode {
+          1 => wgpu_core::device::HostMap::Read,
+          2 => wgpu_core::device::HostMap::Write,
+          _ => unreachable!(),
+        },
+        callback: Some(wgpu_core::resource::BufferMapCallback::from_rust(callback)),
+      }
+    ))
+    .err();
 
     if maybe_err.is_some() {
       return Ok(WebGpuResult::maybe_err(maybe_err));
     }
   }
 
-  let done = Rc::new(RefCell::new(false));
-  let done_ = done.clone();
-  let device_poll_fut = async move {
-    while !*done.borrow() {
-      {
-        let state = state.borrow();
-        let instance = state.borrow::<super::Instance>();
-        gfx_select!(device => instance.device_poll(device, wgpu_types::Maintain::wait()))
-                    .unwrap();
+  loop {
+    let result = done.lock().unwrap().take();
+    match result {
+      Some(Ok(())) => return Ok(WebGpuResult::empty()),
+      Some(Err(e)) => {
+        return Err(DomExceptionOperationError::new(&e.to_string()).into())
+      }
+      None => {
+        {
+          let state = state.borrow();
+          let instance = state.borrow::<super::Instance>();
+          gfx_select!(device => instance.device_poll(device, wgpu_types::Maintain::Poll)).unwrap();
+        }
+        tokio::time::sleep(Duration::from_millis(10)).await;
       }
-      tokio::time::sleep(Duration::from_millis(10)).await;
     }
-    Ok::<(), AnyError>(())
-  };
-
-  let receiver_fut = async move {
-    receiver.await??;
-    let mut done = done_.borrow_mut();
-    *done = true;
-    Ok::<(), AnyError>(())
-  };
-
-  tokio::try_join!(device_poll_fut, receiver_fut)?;
-
-  Ok(WebGpuResult::empty())
+  }
 }
 
 #[op2]