language-servers/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-07-23 21:25:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

refactor(ops): return BadResource errors in ResourceTable calls (#11710)

Browse source 
* refactor(ops): return BadResource errors in ResourceTable calls

Instead of relying on callers to map Options to Results via `.ok_or_else(bad_resource_id)` at over 176 different call sites ...
This commit is contained in:
Aaron O'Mullan 2021-08-15 13:29:19 +02:00 • committed by GitHub
parent 18ff6bb053
commit 2ca454b402
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
34 changed files with 337 additions and 551 deletions
Download patch file Download diff file Expand all files Collapse all files

13
core/bindings.rs
View file

@ -611,13 +611,14 @@ fn wasm_streaming_feed(
let state = state_rc.borrow(); let state = state_rc.borrow();
// If message_type is not Bytes, we'll be consuming the WasmStreaming // If message_type is not Bytes, we'll be consuming the WasmStreaming
// instance, so let's also remove it from the resource table. // instance, so let's also remove it from the resource table.
let wasm_streaming: Option<Rc<WasmStreamingResource>> = match message_type { let wasm_streaming: Result<Rc<WasmStreamingResource>, AnyError> =
MessageType::Bytes => state.op_state.borrow().resource_table.get(rid), match message_type {
_ => state.op_state.borrow_mut().resource_table.take(rid), MessageType::Bytes => state.op_state.borrow().resource_table.get(rid),
}; _ => state.op_state.borrow_mut().resource_table.take(rid),
};
match wasm_streaming { match wasm_streaming {
Some(wasm_streaming) => wasm_streaming, Ok(wasm_streaming) => wasm_streaming,
None => return throw_type_error(scope, "Invalid resource ID."), Err(e) => return throw_type_error(scope, e.to_string()),
} }
}; };

25
core/examples/http_bench_json_ops.rs
View file

@ -1,5 +1,4 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::AsyncRefCell; use deno_core::AsyncRefCell;
@ -140,11 +139,7 @@ fn op_close(
_: (), _: (),
) -> Result<(), AnyError> { ) -> Result<(), AnyError> {
log::debug!("close rid={}", rid); log::debug!("close rid={}", rid);
state state.resource_table.close(rid).map(|_| ())
.resource_table
.close(rid)
.map(|_| ())
.ok_or_else(bad_resource_id)
} }
async fn op_accept( async fn op_accept(
@ -154,11 +149,7 @@ async fn op_accept(
) -> Result<ResourceId, AnyError> { ) -> Result<ResourceId, AnyError> {
log::debug!("accept rid={}", rid); log::debug!("accept rid={}", rid);
let listener = state let listener = state.borrow().resource_table.get::<TcpListener>(rid)?;
.borrow()
.resource_table
.get::<TcpListener>(rid)
.ok_or_else(bad_resource_id)?;
let stream = listener.accept().await?; let stream = listener.accept().await?;
let rid = state.borrow_mut().resource_table.add(stream); let rid = state.borrow_mut().resource_table.add(stream);
Ok(rid) Ok(rid)
@ -172,11 +163,7 @@ async fn op_read(
let mut buf = buf.ok_or_else(null_opbuf)?; let mut buf = buf.ok_or_else(null_opbuf)?;
log::debug!("read rid={}", rid); log::debug!("read rid={}", rid);
let stream = state let stream = state.borrow().resource_table.get::<TcpStream>(rid)?;
.borrow()
.resource_table
.get::<TcpStream>(rid)
.ok_or_else(bad_resource_id)?;
let nread = stream.read(&mut buf).await?; let nread = stream.read(&mut buf).await?;
Ok(nread) Ok(nread)
} }
@ -189,11 +176,7 @@ async fn op_write(
let buf = buf.ok_or_else(null_opbuf)?; let buf = buf.ok_or_else(null_opbuf)?;
log::debug!("write rid={}", rid); log::debug!("write rid={}", rid);
let stream = state let stream = state.borrow().resource_table.get::<TcpStream>(rid)?;
.borrow()
.resource_table
.get::<TcpStream>(rid)
.ok_or_else(bad_resource_id)?;
let nwritten = stream.write(&buf).await?; let nwritten = stream.write(&buf).await?;
Ok(nwritten) Ok(nwritten)
} }

6
core/ops_builtin.rs
View file

@ -1,4 +1,3 @@
use crate::error::bad_resource_id;
use crate::error::type_error; use crate::error::type_error;
use crate::error::AnyError; use crate::error::AnyError;
use crate::include_js_files; use crate::include_js_files;
@ -47,10 +46,7 @@ pub fn op_close(
) -> Result<(), AnyError> { ) -> Result<(), AnyError> {
// TODO(@AaronO): drop Option after improving type-strictness balance in serde_v8 // TODO(@AaronO): drop Option after improving type-strictness balance in serde_v8
let rid = rid.ok_or_else(|| type_error("missing or invalid `rid`"))?; let rid = rid.ok_or_else(|| type_error("missing or invalid `rid`"))?;
state state.resource_table.close(rid)?;
.resource_table
.close(rid)
.ok_or_else(bad_resource_id)?;
Ok(()) Ok(())
} }

35
core/resources.rs
View file

@ -6,6 +6,8 @@
// resources. Resources may or may not correspond to a real operating system // resources. Resources may or may not correspond to a real operating system
// file descriptor (hence the different name). // file descriptor (hence the different name).
use crate::error::bad_resource_id;
use crate::error::AnyError;
use std::any::type_name; use std::any::type_name;
use std::any::Any; use std::any::Any;
use std::any::TypeId; use std::any::TypeId;
@ -105,32 +107,43 @@ impl ResourceTable {
/// Returns a reference counted pointer to the resource of type `T` with the /// Returns a reference counted pointer to the resource of type `T` with the
/// given `rid`. If `rid` is not present or has a type different than `T`, /// given `rid`. If `rid` is not present or has a type different than `T`,
/// this function returns `None`. /// this function returns `None`.
pub fn get<T: Resource>(&self, rid: ResourceId) -> Option<Rc<T>> { pub fn get<T: Resource>(&self, rid: ResourceId) -> Result<Rc<T>, AnyError> {
self self
.index .index
.get(&rid) .get(&rid)
.and_then(|rc| rc.downcast_rc::<T>()) .and_then(|rc| rc.downcast_rc::<T>())
.map(Clone::clone) .map(Clone::clone)
.ok_or_else(bad_resource_id)
} }
pub fn get_any(&self, rid: ResourceId) -> Option<Rc<dyn Resource>> { pub fn get_any(&self, rid: ResourceId) -> Result<Rc<dyn Resource>, AnyError> {
self.index.get(&rid).map(Clone::clone) self
.index
.get(&rid)
.map(Clone::clone)
.ok_or_else(bad_resource_id)
} }
/// Removes a resource of type `T` from the resource table and returns it. /// Removes a resource of type `T` from the resource table and returns it.
/// If a resource with the given `rid` exists but its type does not match `T`, /// If a resource with the given `rid` exists but its type does not match `T`,
/// it is not removed from the resource table. Note that the resource's /// it is not removed from the resource table. Note that the resource's
/// `close()` method is *not* called. /// `close()` method is *not* called.
pub fn take<T: Resource>(&mut self, rid: ResourceId) -> Option<Rc<T>> { pub fn take<T: Resource>(
&mut self,
rid: ResourceId,
) -> Result<Rc<T>, AnyError> {
let resource = self.get::<T>(rid)?; let resource = self.get::<T>(rid)?;
self.index.remove(&rid); self.index.remove(&rid);
Some(resource) Ok(resource)
} }
/// Removes a resource from the resource table and returns it. Note that the /// Removes a resource from the resource table and returns it. Note that the
/// resource's `close()` method is *not* called. /// resource's `close()` method is *not* called.
pub fn take_any(&mut self, rid: ResourceId) -> Option<Rc<dyn Resource>> { pub fn take_any(
self.index.remove(&rid) &mut self,
rid: ResourceId,
) -> Result<Rc<dyn Resource>, AnyError> {
self.index.remove(&rid).ok_or_else(bad_resource_id)
} }
/// Removes the resource with the given `rid` from the resource table. If the /// Removes the resource with the given `rid` from the resource table. If the
@ -139,8 +152,12 @@ impl ResourceTable {
/// counted, therefore pending ops are not automatically cancelled. A resource /// counted, therefore pending ops are not automatically cancelled. A resource
/// may implement the `close()` method to perform clean-ups such as canceling /// may implement the `close()` method to perform clean-ups such as canceling
/// ops. /// ops.
pub fn close(&mut self, rid: ResourceId) -> Option<()> { pub fn close(&mut self, rid: ResourceId) -> Result<(), AnyError> {
self.index.remove(&rid).map(|resource| resource.close()) self
.index
.remove(&rid)
.ok_or_else(bad_resource_id)
.map(|resource| resource.close())
} }
/// Returns an iterator that yields a `(id, name)` pair for every resource /// Returns an iterator that yields a `(id, name)` pair for every resource

18
ext/broadcast_channel/lib.rs
View file

@ -5,7 +5,6 @@ mod in_memory_broadcast_channel;
pub use in_memory_broadcast_channel::InMemoryBroadcastChannel; pub use in_memory_broadcast_channel::InMemoryBroadcastChannel;
use async_trait::async_trait; use async_trait::async_trait;
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::include_js_files; use deno_core::include_js_files;
use deno_core::op_async; use deno_core::op_async;
@ -68,10 +67,7 @@ pub fn op_broadcast_unsubscribe<BC: BroadcastChannel + 'static>(
rid: ResourceId, rid: ResourceId,
_buf: (), _buf: (),
) -> Result<(), AnyError> { ) -> Result<(), AnyError> {
let resource = state let resource = state.resource_table.get::<BC::Resource>(rid)?;
.resource_table
.get::<BC::Resource>(rid)
.ok_or_else(bad_resource_id)?;
let bc = state.borrow::<BC>(); let bc = state.borrow::<BC>();
bc.unsubscribe(&resource) bc.unsubscribe(&resource)
} }
@ -81,11 +77,7 @@ pub async fn op_broadcast_send<BC: BroadcastChannel + 'static>(
(rid, name): (ResourceId, String), (rid, name): (ResourceId, String),
buf: ZeroCopyBuf, buf: ZeroCopyBuf,
) -> Result<(), AnyError> { ) -> Result<(), AnyError> {
let resource = state let resource = state.borrow().resource_table.get::<BC::Resource>(rid)?;
.borrow()
.resource_table
.get::<BC::Resource>(rid)
.ok_or_else(bad_resource_id)?;
let bc = state.borrow().borrow::<BC>().clone(); let bc = state.borrow().borrow::<BC>().clone();
bc.send(&resource, name, buf.to_vec()).await bc.send(&resource, name, buf.to_vec()).await
} }
@ -95,11 +87,7 @@ pub async fn op_broadcast_recv<BC: BroadcastChannel + 'static>(
rid: ResourceId, rid: ResourceId,
_buf: (), _buf: (),
) -> Result<Option<Message>, AnyError> { ) -> Result<Option<Message>, AnyError> {
let resource = state let resource = state.borrow().resource_table.get::<BC::Resource>(rid)?;
.borrow()
.resource_table
.get::<BC::Resource>(rid)
.ok_or_else(bad_resource_id)?;
let bc = state.borrow().borrow::<BC>().clone(); let bc = state.borrow().borrow::<BC>().clone();
bc.recv(&resource).await bc.recv(&resource).await
} }

15
ext/fetch/lib.rs
View file

@ -1,7 +1,6 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use data_url::DataUrl; use data_url::DataUrl;
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::type_error; use deno_core::error::type_error;
use deno_core::error::AnyError; use deno_core::error::AnyError;
@ -163,10 +162,7 @@ where
FP: FetchPermissions + 'static, FP: FetchPermissions + 'static,
{ {
let client = if let Some(rid) = args.client_rid { let client = if let Some(rid) = args.client_rid {
let r = state let r = state.resource_table.get::<HttpClientResource>(rid)?;
.resource_table
.get::<HttpClientResource>(rid)
.ok_or_else(bad_resource_id)?;
r.client.clone() r.client.clone()
} else { } else {
let client = state.borrow::<reqwest::Client>(); let client = state.borrow::<reqwest::Client>();
@ -345,8 +341,7 @@ pub async fn op_fetch_send(
let request = state let request = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.take::<FetchRequestResource>(rid) .take::<FetchRequestResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let request = Rc::try_unwrap(request) let request = Rc::try_unwrap(request)
.ok() .ok()
@ -402,8 +397,7 @@ pub async fn op_fetch_request_write(
let resource = state let resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<FetchRequestBodyResource>(rid) .get::<FetchRequestBodyResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let body = RcRef::map(&resource, |r| &r.body).borrow_mut().await; let body = RcRef::map(&resource, |r| &r.body).borrow_mut().await;
let cancel = RcRef::map(resource, |r| &r.cancel); let cancel = RcRef::map(resource, |r| &r.cancel);
body.send(Ok(buf)).or_cancel(cancel).await?.map_err(|_| { body.send(Ok(buf)).or_cancel(cancel).await?.map_err(|_| {
@ -423,8 +417,7 @@ pub async fn op_fetch_response_read(
let resource = state let resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<FetchResponseBodyResource>(rid) .get::<FetchResponseBodyResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let mut reader = RcRef::map(&resource, |r| &r.reader).borrow_mut().await; let mut reader = RcRef::map(&resource, |r| &r.reader).borrow_mut().await;
let cancel = RcRef::map(resource, |r| &r.cancel); let cancel = RcRef::map(resource, |r| &r.cancel);
let mut buf = data.clone(); let mut buf = data.clone();

3
ext/ffi/lib.rs
View file

@ -329,8 +329,7 @@ fn op_ffi_call(
) -> Result<Value, AnyError> { ) -> Result<Value, AnyError> {
let resource = state let resource = state
.resource_table .resource_table
.get::<DynamicLibraryResource>(args.rid) .get::<DynamicLibraryResource>(args.rid)?;
.ok_or_else(bad_resource_id)?;
let symbol = resource let symbol = resource
.symbols .symbols

32
ext/http/lib.rs
View file

@ -175,8 +175,7 @@ async fn op_http_request_next(
let conn_resource = state let conn_resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<ConnResource>(conn_rid) .get::<ConnResource>(conn_rid)?;
.ok_or_else(bad_resource_id)?;
let cancel = RcRef::map(conn_resource.clone(), |r| &r.cancel); let cancel = RcRef::map(conn_resource.clone(), |r| &r.cancel);
@ -395,8 +394,7 @@ async fn op_http_response(
let response_sender = state let response_sender = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.take::<ResponseSenderResource>(rid) .take::<ResponseSenderResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let response_sender = Rc::try_unwrap(response_sender) let response_sender = Rc::try_unwrap(response_sender)
.ok() .ok()
.expect("multiple op_http_respond ongoing"); .expect("multiple op_http_respond ongoing");
@ -406,8 +404,7 @@ async fn op_http_response(
let conn_resource = state let conn_resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<ConnResource>(conn_rid) .get::<ConnResource>(conn_rid)?;
.ok_or_else(bad_resource_id)?;
let mut builder = Response::builder().status(status); let mut builder = Response::builder().status(status);
@ -444,7 +441,7 @@ async fn op_http_response(
poll_fn(|cx| match conn_resource.poll(cx) { poll_fn(|cx| match conn_resource.poll(cx) {
Poll::Ready(x) => { Poll::Ready(x) => {
state.borrow_mut().resource_table.close(conn_rid); state.borrow_mut().resource_table.close(conn_rid).ok();
Poll::Ready(x) Poll::Ready(x)
} }
Poll::Pending => Poll::Ready(Ok(())), Poll::Pending => Poll::Ready(Ok(())),
@ -465,14 +462,12 @@ async fn op_http_response_close(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.take::<ResponseBodyResource>(rid) .take::<ResponseBodyResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let conn_resource = state let conn_resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<ConnResource>(resource.conn_rid) .get::<ConnResource>(resource.conn_rid)?;
.ok_or_else(bad_resource_id)?;
drop(resource); drop(resource);
let r = poll_fn(|cx| match conn_resource.poll(cx) { let r = poll_fn(|cx| match conn_resource.poll(cx) {
@ -494,14 +489,12 @@ async fn op_http_request_read(
let resource = state let resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<RequestResource>(rid as u32) .get::<RequestResource>(rid as u32)?;
.ok_or_else(bad_resource_id)?;
let conn_resource = state let conn_resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<ConnResource>(resource.conn_rid) .get::<ConnResource>(resource.conn_rid)?;
.ok_or_else(bad_resource_id)?;
let mut inner = RcRef::map(resource.clone(), |r| &r.inner) let mut inner = RcRef::map(resource.clone(), |r| &r.inner)
.borrow_mut() .borrow_mut()
@ -547,14 +540,12 @@ async fn op_http_response_write(
let resource = state let resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<ResponseBodyResource>(rid as u32) .get::<ResponseBodyResource>(rid as u32)?;
.ok_or_else(bad_resource_id)?;
let conn_resource = state let conn_resource = state
.borrow() .borrow()
.resource_table .resource_table
.get::<ConnResource>(resource.conn_rid) .get::<ConnResource>(resource.conn_rid)?;
.ok_or_else(bad_resource_id)?;
let mut body = RcRef::map(&resource, |r| &r.body).borrow_mut().await; let mut body = RcRef::map(&resource, |r| &r.body).borrow_mut().await;
@ -598,8 +589,7 @@ async fn op_http_upgrade_websocket(
let req_resource = state let req_resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.take::<RequestResource>(rid) .take::<RequestResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let mut inner = RcRef::map(&req_resource, |r| &r.inner).borrow_mut().await; let mut inner = RcRef::map(&req_resource, |r| &r.inner).borrow_mut().await;

20
ext/net/io.rs
View file

@ -1,9 +1,9 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use crate::ops_tls as tls; use crate::ops_tls as tls;
use deno_core::error::not_supported;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::error::{bad_resource_id, not_supported};
use deno_core::op_async; use deno_core::op_async;
use deno_core::AsyncMutFuture; use deno_core::AsyncMutFuture;
use deno_core::AsyncRefCell; use deno_core::AsyncRefCell;
@ -169,11 +169,7 @@ async fn op_read_async(
buf: Option<ZeroCopyBuf>, buf: Option<ZeroCopyBuf>,
) -> Result<u32, AnyError> { ) -> Result<u32, AnyError> {
let buf = &mut buf.ok_or_else(null_opbuf)?; let buf = &mut buf.ok_or_else(null_opbuf)?;
let resource = state let resource = state.borrow().resource_table.get_any(rid)?;
.borrow()
.resource_table
.get_any(rid)
.ok_or_else(bad_resource_id)?;
let nread = if let Some(s) = resource.downcast_rc::<TcpStreamResource>() { let nread = if let Some(s) = resource.downcast_rc::<TcpStreamResource>() {
s.read(buf).await? s.read(buf).await?
} else if let Some(s) = resource.downcast_rc::<TlsStreamResource>() { } else if let Some(s) = resource.downcast_rc::<TlsStreamResource>() {
@ -192,11 +188,7 @@ async fn op_write_async(
buf: Option<ZeroCopyBuf>, buf: Option<ZeroCopyBuf>,
) -> Result<u32, AnyError> { ) -> Result<u32, AnyError> {
let buf = &buf.ok_or_else(null_opbuf)?; let buf = &buf.ok_or_else(null_opbuf)?;
let resource = state let resource = state.borrow().resource_table.get_any(rid)?;
.borrow()
.resource_table
.get_any(rid)
.ok_or_else(bad_resource_id)?;
let nwritten = if let Some(s) = resource.downcast_rc::<TcpStreamResource>() { let nwritten = if let Some(s) = resource.downcast_rc::<TcpStreamResource>() {
s.write(buf).await? s.write(buf).await?
} else if let Some(s) = resource.downcast_rc::<TlsStreamResource>() { } else if let Some(s) = resource.downcast_rc::<TlsStreamResource>() {
@ -214,11 +206,7 @@ async fn op_shutdown(
rid: ResourceId, rid: ResourceId,
_: (), _: (),
) -> Result<(), AnyError> { ) -> Result<(), AnyError> {
let resource = state let resource = state.borrow().resource_table.get_any(rid)?;
.borrow()
.resource_table
.get_any(rid)
.ok_or_else(bad_resource_id)?;
if let Some(s) = resource.downcast_rc::<TcpStreamResource>() { if let Some(s) = resource.downcast_rc::<TcpStreamResource>() {
s.shutdown().await?; s.shutdown().await?;
} else if let Some(s) = resource.downcast_rc::<TlsStreamResource>() { } else if let Some(s) = resource.downcast_rc::<TlsStreamResource>() {

10
ext/net/ops.rs
View file

@ -107,7 +107,7 @@ async fn accept_tcp(
.borrow() .borrow()
.resource_table .resource_table
.get::<TcpListenerResource>(rid) .get::<TcpListenerResource>(rid)
.ok_or_else(|| bad_resource("Listener has been closed"))?; .map_err(|_| bad_resource("Listener has been closed"))?;
let listener = RcRef::map(&resource, |r| &r.listener) let listener = RcRef::map(&resource, |r| &r.listener)
.try_borrow_mut() .try_borrow_mut()
.ok_or_else(|| custom_error("Busy", "Another accept task is ongoing"))?; .ok_or_else(|| custom_error("Busy", "Another accept task is ongoing"))?;
@ -178,7 +178,7 @@ async fn receive_udp(
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<UdpSocketResource>(rid) .get::<UdpSocketResource>(rid)
.ok_or_else(|| bad_resource("Socket has been closed"))?; .map_err(|_| bad_resource("Socket has been closed"))?;
let socket = RcRef::map(&resource, |r| &r.socket).borrow().await; let socket = RcRef::map(&resource, |r| &r.socket).borrow().await;
let cancel_handle = RcRef::map(&resource, |r| &r.cancel); let cancel_handle = RcRef::map(&resource, |r| &r.cancel);
let (size, remote_addr) = socket let (size, remote_addr) = socket
@ -246,7 +246,7 @@ where
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<UdpSocketResource>(rid) .get::<UdpSocketResource>(rid)
.ok_or_else(|| bad_resource("Socket has been closed"))?; .map_err(|_| bad_resource("Socket has been closed"))?;
let socket = RcRef::map(&resource, |r| &r.socket).borrow().await; let socket = RcRef::map(&resource, |r| &r.socket).borrow().await;
let byte_length = socket.send_to(&zero_copy, &addr).await?; let byte_length = socket.send_to(&zero_copy, &addr).await?;
Ok(byte_length) Ok(byte_length)
@ -266,9 +266,7 @@ where
.borrow() .borrow()
.resource_table .resource_table
.get::<net_unix::UnixDatagramResource>(rid) .get::<net_unix::UnixDatagramResource>(rid)
.ok_or_else(|| { .map_err(|_| custom_error("NotConnected", "Socket has been closed"))?;
custom_error("NotConnected", "Socket has been closed")
})?;
let socket = RcRef::map(&resource, |r| &r.socket) let socket = RcRef::map(&resource, |r| &r.socket)
.try_borrow_mut() .try_borrow_mut()
.ok_or_else(|| custom_error("Busy", "Socket already in use"))?; .ok_or_else(|| custom_error("Busy", "Socket already in use"))?;

6
ext/net/ops_tls.rs
View file

@ -11,7 +11,6 @@ use crate::DefaultTlsOptions;
use crate::NetPermissions; use crate::NetPermissions;
use crate::UnsafelyIgnoreCertificateErrors; use crate::UnsafelyIgnoreCertificateErrors;
use deno_core::error::bad_resource; use deno_core::error::bad_resource;
use deno_core::error::bad_resource_id;
use deno_core::error::custom_error; use deno_core::error::custom_error;
use deno_core::error::generic_error; use deno_core::error::generic_error;
use deno_core::error::invalid_hostname; use deno_core::error::invalid_hostname;
@ -717,8 +716,7 @@ where
let resource_rc = state let resource_rc = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.take::<TcpStreamResource>(rid) .take::<TcpStreamResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let resource = Rc::try_unwrap(resource_rc) let resource = Rc::try_unwrap(resource_rc)
.expect("Only a single use of this resource should happen"); .expect("Only a single use of this resource should happen");
let (read_half, write_half) = resource.into_inner(); let (read_half, write_half) = resource.into_inner();
@ -1019,7 +1017,7 @@ async fn op_accept_tls(
.borrow() .borrow()
.resource_table .resource_table
.get::<TlsListenerResource>(rid) .get::<TlsListenerResource>(rid)
.ok_or_else(|| bad_resource("Listener has been closed"))?; .map_err(|_| bad_resource("Listener has been closed"))?;
let cancel_handle = RcRef::map(&resource, |r| &r.cancel_handle); let cancel_handle = RcRef::map(&resource, |r| &r.cancel_handle);
let tcp_listener = RcRef::map(&resource, |r| &r.tcp_listener) let tcp_listener = RcRef::map(&resource, |r| &r.tcp_listener)

4
ext/net/ops_unix.rs
View file

@ -87,7 +87,7 @@ pub(crate) async fn accept_unix(
.borrow() .borrow()
.resource_table .resource_table
.get::<UnixListenerResource>(rid) .get::<UnixListenerResource>(rid)
.ok_or_else(|| bad_resource("Listener has been closed"))?; .map_err(|_| bad_resource("Listener has been closed"))?;
let listener = RcRef::map(&resource, |r| &r.listener) let listener = RcRef::map(&resource, |r| &r.listener)
.try_borrow_mut() .try_borrow_mut()
.ok_or_else(|| custom_error("Busy", "Listener already in use"))?; .ok_or_else(|| custom_error("Busy", "Listener already in use"))?;
@ -124,7 +124,7 @@ pub(crate) async fn receive_unix_packet(
.borrow() .borrow()
.resource_table .resource_table
.get::<UnixDatagramResource>(rid) .get::<UnixDatagramResource>(rid)
.ok_or_else(|| bad_resource("Socket has been closed"))?; .map_err(|_| bad_resource("Socket has been closed"))?;
let socket = RcRef::map(&resource, |r| &r.socket) let socket = RcRef::map(&resource, |r| &r.socket)
.try_borrow_mut() .try_borrow_mut()
.ok_or_else(|| custom_error("Busy", "Socket already in use"))?; .ok_or_else(|| custom_error("Busy", "Socket already in use"))?;

6
ext/web/lib.rs
View file

@ -3,7 +3,6 @@
mod blob; mod blob;
mod message_port; mod message_port;
use deno_core::error::bad_resource_id;
use deno_core::error::range_error; use deno_core::error::range_error;
use deno_core::error::type_error; use deno_core::error::type_error;
use deno_core::error::AnyError; use deno_core::error::AnyError;
@ -240,10 +239,7 @@ fn op_encoding_decode(
) -> Result<String, AnyError> { ) -> Result<String, AnyError> {
let DecodeOptions { rid, stream } = options; let DecodeOptions { rid, stream } = options;
let resource = state let resource = state.resource_table.get::<TextDecoderResource>(rid)?;
.resource_table
.get::<TextDecoderResource>(rid)
.ok_or_else(bad_resource_id)?;
let mut decoder = resource.decoder.borrow_mut(); let mut decoder = resource.decoder.borrow_mut();
let fatal = resource.fatal; let fatal = resource.fatal;

12
ext/web/message_port.rs
View file

@ -2,7 +2,6 @@ use std::borrow::Cow;
use std::cell::RefCell; use std::cell::RefCell;
use std::rc::Rc; use std::rc::Rc;
use deno_core::error::bad_resource_id;
use deno_core::error::type_error; use deno_core::error::type_error;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::ZeroCopyBuf; use deno_core::ZeroCopyBuf;
@ -141,7 +140,7 @@ fn deserialize_js_transferables(
let resource = state let resource = state
.resource_table .resource_table
.take::<MessagePortResource>(id) .take::<MessagePortResource>(id)
.ok_or_else(|| type_error("Invalid message port transfer"))?; .map_err(|_| type_error("Invalid message port transfer"))?;
resource.cancel.cancel(); resource.cancel.cancel();
let resource = Rc::try_unwrap(resource) let resource = Rc::try_unwrap(resource)
.map_err(|_| type_error("Message port is not ready for transfer"))?; .map_err(|_| type_error("Message port is not ready for transfer"))?;
@ -192,10 +191,7 @@ pub fn op_message_port_post_message(
} }
} }
let resource = state let resource = state.resource_table.get::<MessagePortResource>(rid)?;
.resource_table
.get::<MessagePortResource>(rid)
.ok_or_else(bad_resource_id)?;
resource.port.send(state, data) resource.port.send(state, data)
} }
@ -208,8 +204,8 @@ pub async fn op_message_port_recv_message(
let resource = { let resource = {
let state = state.borrow(); let state = state.borrow();
match state.resource_table.get::<MessagePortResource>(rid) { match state.resource_table.get::<MessagePortResource>(rid) {
Some(resource) => resource, Ok(resource) => resource,
None => return Ok(None), Err(_) => return Ok(None),
} }
}; };
let cancel = RcRef::map(resource.clone(), |r| &r.cancel); let cancel = RcRef::map(resource.clone(), |r| &r.cancel);

43
ext/webgpu/binding.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::ResourceId; use deno_core::ResourceId;
use deno_core::{OpState, Resource}; use deno_core::{OpState, Resource};
@ -84,8 +83,7 @@ pub fn op_webgpu_create_bind_group_layout(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let mut entries = vec![]; let mut entries = vec![];
@ -217,17 +215,14 @@ pub fn op_webgpu_create_pipeline_layout(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let mut bind_group_layouts = vec![]; let mut bind_group_layouts = vec![];
for rid in &args.bind_group_layouts { for rid in &args.bind_group_layouts {
let bind_group_layout = state let bind_group_layout =
.resource_table state.resource_table.get::<WebGpuBindGroupLayout>(*rid)?;
.get::<WebGpuBindGroupLayout>(*rid)
.ok_or_else(bad_resource_id)?;
bind_group_layouts.push(bind_group_layout.0); bind_group_layouts.push(bind_group_layout.0);
} }
@ -271,8 +266,7 @@ pub fn op_webgpu_create_bind_group(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let mut entries = vec![]; let mut entries = vec![];
@ -282,26 +276,26 @@ pub fn op_webgpu_create_bind_group(
binding: entry.binding, binding: entry.binding,
resource: match entry.kind.as_str() { resource: match entry.kind.as_str() {
"GPUSampler" => { "GPUSampler" => {
let sampler_resource = state let sampler_resource =
.resource_table state
.get::<super::sampler::WebGpuSampler>(entry.resource) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::sampler::WebGpuSampler>(entry.resource)?;
wgpu_core::binding_model::BindingResource::Sampler(sampler_resource.0) wgpu_core::binding_model::BindingResource::Sampler(sampler_resource.0)
} }
"GPUTextureView" => { "GPUTextureView" => {
let texture_view_resource = state let texture_view_resource =
.resource_table state
.get::<super::texture::WebGpuTextureView>(entry.resource) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::texture::WebGpuTextureView>(entry.resource)?;
wgpu_core::binding_model::BindingResource::TextureView( wgpu_core::binding_model::BindingResource::TextureView(
texture_view_resource.0, texture_view_resource.0,
) )
} }
"GPUBufferBinding" => { "GPUBufferBinding" => {
let buffer_resource = state let buffer_resource =
.resource_table state
.get::<super::buffer::WebGpuBuffer>(entry.resource) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::buffer::WebGpuBuffer>(entry.resource)?;
wgpu_core::binding_model::BindingResource::Buffer( wgpu_core::binding_model::BindingResource::Buffer(
wgpu_core::binding_model::BufferBinding { wgpu_core::binding_model::BufferBinding {
buffer_id: buffer_resource.0, buffer_id: buffer_resource.0,
@ -318,8 +312,7 @@ pub fn op_webgpu_create_bind_group(
let bind_group_layout = state let bind_group_layout = state
.resource_table .resource_table
.get::<WebGpuBindGroupLayout>(args.layout) .get::<WebGpuBindGroupLayout>(args.layout)?;
.ok_or_else(bad_resource_id)?;
let descriptor = wgpu_core::binding_model::BindGroupDescriptor { let descriptor = wgpu_core::binding_model::BindGroupDescriptor {
label: args.label.map(Cow::from), label: args.label.map(Cow::from),

28
ext/webgpu/buffer.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::type_error; use deno_core::error::type_error;
use deno_core::error::AnyError; use deno_core::error::AnyError;
@ -50,8 +49,7 @@ pub fn op_webgpu_create_buffer(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let descriptor = wgpu_core::resource::BufferDescriptor { let descriptor = wgpu_core::resource::BufferDescriptor {
@ -90,15 +88,12 @@ pub async fn op_webgpu_buffer_get_map_async(
{ {
let state_ = state.borrow(); let state_ = state.borrow();
let instance = state_.borrow::<super::Instance>(); let instance = state_.borrow::<super::Instance>();
let buffer_resource = state_ let buffer_resource =
.resource_table state_.resource_table.get::<WebGpuBuffer>(args.buffer_rid)?;
.get::<WebGpuBuffer>(args.buffer_rid)
.ok_or_else(bad_resource_id)?;
let buffer = buffer_resource.0; let buffer = buffer_resource.0;
let device_resource = state_ let device_resource = state_
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
device = device_resource.0; device = device_resource.0;
let boxed_sender = Box::new(sender); let boxed_sender = Box::new(sender);
@ -180,10 +175,8 @@ pub fn op_webgpu_buffer_get_mapped_range(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let mut zero_copy = zero_copy.ok_or_else(null_opbuf)?; let mut zero_copy = zero_copy.ok_or_else(null_opbuf)?;
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let buffer_resource = state let buffer_resource =
.resource_table state.resource_table.get::<WebGpuBuffer>(args.buffer_rid)?;
.get::<WebGpuBuffer>(args.buffer_rid)
.ok_or_else(bad_resource_id)?;
let buffer = buffer_resource.0; let buffer = buffer_resource.0;
let (slice_pointer, range_size) = let (slice_pointer, range_size) =
@ -220,13 +213,10 @@ pub fn op_webgpu_buffer_unmap(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let mapped_resource = state let mapped_resource = state
.resource_table .resource_table
.take::<WebGpuBufferMapped>(args.mapped_rid) .take::<WebGpuBufferMapped>(args.mapped_rid)?;
.ok_or_else(bad_resource_id)?;
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let buffer_resource = state let buffer_resource =
.resource_table state.resource_table.get::<WebGpuBuffer>(args.buffer_rid)?;
.get::<WebGpuBuffer>(args.buffer_rid)
.ok_or_else(bad_resource_id)?;
let buffer = buffer_resource.0; let buffer = buffer_resource.0;
let slice_pointer = mapped_resource.0; let slice_pointer = mapped_resource.0;

117
ext/webgpu/bundle.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::ResourceId; use deno_core::ResourceId;
@ -47,8 +46,7 @@ pub fn op_webgpu_create_render_bundle_encoder(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let mut color_formats = vec![]; let mut color_formats = vec![];
@ -98,10 +96,10 @@ pub fn op_webgpu_render_bundle_encoder_finish(
args: RenderBundleEncoderFinishArgs, args: RenderBundleEncoderFinishArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state let render_bundle_encoder_resource =
.resource_table state
.take::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .resource_table
.ok_or_else(bad_resource_id)?; .take::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
let render_bundle_encoder = Rc::try_unwrap(render_bundle_encoder_resource) let render_bundle_encoder = Rc::try_unwrap(render_bundle_encoder_resource)
.ok() .ok()
.expect("unwrapping render_bundle_encoder_resource should succeed") .expect("unwrapping render_bundle_encoder_resource should succeed")
@ -134,14 +132,14 @@ pub fn op_webgpu_render_bundle_encoder_set_bind_group(
args: RenderBundleEncoderSetBindGroupArgs, args: RenderBundleEncoderSetBindGroupArgs,
zero_copy: Option<ZeroCopyBuf>, zero_copy: Option<ZeroCopyBuf>,
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let bind_group_resource = state let bind_group_resource =
.resource_table state
.get::<super::binding::WebGpuBindGroup>(args.bind_group) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::binding::WebGpuBindGroup>(args.bind_group)?;
let render_bundle_encoder_resource = state let render_bundle_encoder_resource =
.resource_table state
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
// I know this might look like it can be easily deduplicated, but it can not // I know this might look like it can be easily deduplicated, but it can not
// be due to the lifetime of the args.dynamic_offsets_data slice. Because we // be due to the lifetime of the args.dynamic_offsets_data slice. Because we
@ -190,10 +188,10 @@ pub fn op_webgpu_render_bundle_encoder_push_debug_group(
args: RenderBundleEncoderPushDebugGroupArgs, args: RenderBundleEncoderPushDebugGroupArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state let render_bundle_encoder_resource =
.resource_table state
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
unsafe { unsafe {
let label = std::ffi::CString::new(args.group_label).unwrap(); let label = std::ffi::CString::new(args.group_label).unwrap();
@ -217,10 +215,10 @@ pub fn op_webgpu_render_bundle_encoder_pop_debug_group(
args: RenderBundleEncoderPopDebugGroupArgs, args: RenderBundleEncoderPopDebugGroupArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state let render_bundle_encoder_resource =
.resource_table state
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
wgpu_core::command::bundle_ffi::wgpu_render_bundle_pop_debug_group( wgpu_core::command::bundle_ffi::wgpu_render_bundle_pop_debug_group(
&mut render_bundle_encoder_resource.0.borrow_mut(), &mut render_bundle_encoder_resource.0.borrow_mut(),
@ -241,10 +239,10 @@ pub fn op_webgpu_render_bundle_encoder_insert_debug_marker(
args: RenderBundleEncoderInsertDebugMarkerArgs, args: RenderBundleEncoderInsertDebugMarkerArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state let render_bundle_encoder_resource =
.resource_table state
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
unsafe { unsafe {
let label = std::ffi::CString::new(args.marker_label).unwrap(); let label = std::ffi::CString::new(args.marker_label).unwrap();
@ -269,14 +267,14 @@ pub fn op_webgpu_render_bundle_encoder_set_pipeline(
args: RenderBundleEncoderSetPipelineArgs, args: RenderBundleEncoderSetPipelineArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pipeline_resource = state let render_pipeline_resource =
.resource_table state
.get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)?;
let render_bundle_encoder_resource = state let render_bundle_encoder_resource =
.resource_table state
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
wgpu_core::command::bundle_ffi::wgpu_render_bundle_set_pipeline( wgpu_core::command::bundle_ffi::wgpu_render_bundle_set_pipeline(
&mut render_bundle_encoder_resource.0.borrow_mut(), &mut render_bundle_encoder_resource.0.borrow_mut(),
@ -303,12 +301,11 @@ pub fn op_webgpu_render_bundle_encoder_set_index_buffer(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer) .get::<super::buffer::WebGpuBuffer>(args.buffer)?;
.ok_or_else(bad_resource_id)?; let render_bundle_encoder_resource =
let render_bundle_encoder_resource = state state
.resource_table .resource_table
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
render_bundle_encoder_resource render_bundle_encoder_resource
.0 .0
@ -340,12 +337,11 @@ pub fn op_webgpu_render_bundle_encoder_set_vertex_buffer(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer) .get::<super::buffer::WebGpuBuffer>(args.buffer)?;
.ok_or_else(bad_resource_id)?; let render_bundle_encoder_resource =
let render_bundle_encoder_resource = state state
.resource_table .resource_table
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::bundle_ffi::wgpu_render_bundle_set_vertex_buffer( wgpu_core::command::bundle_ffi::wgpu_render_bundle_set_vertex_buffer(
&mut render_bundle_encoder_resource.0.borrow_mut(), &mut render_bundle_encoder_resource.0.borrow_mut(),
@ -373,10 +369,10 @@ pub fn op_webgpu_render_bundle_encoder_draw(
args: RenderBundleEncoderDrawArgs, args: RenderBundleEncoderDrawArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state let render_bundle_encoder_resource =
.resource_table state
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw( wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw(
&mut render_bundle_encoder_resource.0.borrow_mut(), &mut render_bundle_encoder_resource.0.borrow_mut(),
@ -405,10 +401,10 @@ pub fn op_webgpu_render_bundle_encoder_draw_indexed(
args: RenderBundleEncoderDrawIndexedArgs, args: RenderBundleEncoderDrawIndexedArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state let render_bundle_encoder_resource =
.resource_table state
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw_indexed( wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw_indexed(
&mut render_bundle_encoder_resource.0.borrow_mut(), &mut render_bundle_encoder_resource.0.borrow_mut(),
@ -437,12 +433,11 @@ pub fn op_webgpu_render_bundle_encoder_draw_indirect(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.indirect_buffer) .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)?;
.ok_or_else(bad_resource_id)?; let render_bundle_encoder_resource =
let render_bundle_encoder_resource = state state
.resource_table .resource_table
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid) .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw_indirect( wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw_indirect(
&mut render_bundle_encoder_resource.0.borrow_mut(), &mut render_bundle_encoder_resource.0.borrow_mut(),

130
ext/webgpu/command_encoder.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::ResourceId; use deno_core::ResourceId;
use deno_core::{OpState, Resource}; use deno_core::{OpState, Resource};
@ -53,8 +52,7 @@ pub fn op_webgpu_create_command_encoder(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let descriptor = wgpu_types::CommandEncoderDescriptor { let descriptor = wgpu_types::CommandEncoderDescriptor {
@ -109,16 +107,15 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let mut color_attachments = vec![]; let mut color_attachments = vec![];
for color_attachment in args.color_attachments { for color_attachment in args.color_attachments {
let texture_view_resource = state let texture_view_resource =
.resource_table state
.get::<super::texture::WebGpuTextureView>(color_attachment.view) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::texture::WebGpuTextureView>(color_attachment.view)?;
let attachment = wgpu_core::command::RenderPassColorAttachment { let attachment = wgpu_core::command::RenderPassColorAttachment {
view: texture_view_resource.0, view: texture_view_resource.0,
@ -128,7 +125,6 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
state state
.resource_table .resource_table
.get::<super::texture::WebGpuTextureView>(rid) .get::<super::texture::WebGpuTextureView>(rid)
.ok_or_else(bad_resource_id)
}) })
.transpose()? .transpose()?
.map(|texture| texture.0), .map(|texture| texture.0),
@ -167,10 +163,10 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
let mut depth_stencil_attachment = None; let mut depth_stencil_attachment = None;
if let Some(attachment) = args.depth_stencil_attachment { if let Some(attachment) = args.depth_stencil_attachment {
let texture_view_resource = state let texture_view_resource =
.resource_table state
.get::<super::texture::WebGpuTextureView>(attachment.view) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::texture::WebGpuTextureView>(attachment.view)?;
depth_stencil_attachment = depth_stencil_attachment =
Some(wgpu_core::command::RenderPassDepthStencilAttachment { Some(wgpu_core::command::RenderPassDepthStencilAttachment {
@ -242,8 +238,7 @@ pub fn op_webgpu_command_encoder_begin_compute_pass(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let descriptor = wgpu_core::command::ComputePassDescriptor { let descriptor = wgpu_core::command::ComputePassDescriptor {
label: args.label.map(Cow::from), label: args.label.map(Cow::from),
@ -282,18 +277,17 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let source_buffer_resource = state let source_buffer_resource =
.resource_table state
.get::<super::buffer::WebGpuBuffer>(args.source) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::buffer::WebGpuBuffer>(args.source)?;
let source_buffer = source_buffer_resource.0; let source_buffer = source_buffer_resource.0;
let destination_buffer_resource = state let destination_buffer_resource =
.resource_table state
.get::<super::buffer::WebGpuBuffer>(args.destination) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::buffer::WebGpuBuffer>(args.destination)?;
let destination_buffer = destination_buffer_resource.0; let destination_buffer = destination_buffer_resource.0;
gfx_ok!(command_encoder => instance.command_encoder_copy_buffer_to_buffer( gfx_ok!(command_encoder => instance.command_encoder_copy_buffer_to_buffer(
@ -349,17 +343,16 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let source_buffer_resource = state let source_buffer_resource =
.resource_table state
.get::<super::buffer::WebGpuBuffer>(args.source.buffer) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::buffer::WebGpuBuffer>(args.source.buffer)?;
let destination_texture_resource = state let destination_texture_resource =
.resource_table state
.get::<super::texture::WebGpuTexture>(args.destination.texture) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::texture::WebGpuTexture>(args.destination.texture)?;
let source = wgpu_core::command::ImageCopyBuffer { let source = wgpu_core::command::ImageCopyBuffer {
buffer: source_buffer_resource.0, buffer: source_buffer_resource.0,
@ -410,17 +403,16 @@ pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let source_texture_resource = state let source_texture_resource =
.resource_table state
.get::<super::texture::WebGpuTexture>(args.source.texture) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::texture::WebGpuTexture>(args.source.texture)?;
let destination_buffer_resource = state let destination_buffer_resource =
.resource_table state
.get::<super::buffer::WebGpuBuffer>(args.destination.buffer) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::buffer::WebGpuBuffer>(args.destination.buffer)?;
let source = wgpu_core::command::ImageCopyTexture { let source = wgpu_core::command::ImageCopyTexture {
texture: source_texture_resource.0, texture: source_texture_resource.0,
@ -474,17 +466,16 @@ pub fn op_webgpu_command_encoder_copy_texture_to_texture(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let source_texture_resource = state let source_texture_resource =
.resource_table state
.get::<super::texture::WebGpuTexture>(args.source.texture) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::texture::WebGpuTexture>(args.source.texture)?;
let destination_texture_resource = state let destination_texture_resource =
.resource_table state
.get::<super::texture::WebGpuTexture>(args.destination.texture) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::texture::WebGpuTexture>(args.destination.texture)?;
let source = wgpu_core::command::ImageCopyTexture { let source = wgpu_core::command::ImageCopyTexture {
texture: source_texture_resource.0, texture: source_texture_resource.0,
@ -536,8 +527,7 @@ pub fn op_webgpu_command_encoder_push_debug_group(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
gfx_ok!(command_encoder => instance gfx_ok!(command_encoder => instance
@ -558,8 +548,7 @@ pub fn op_webgpu_command_encoder_pop_debug_group(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
gfx_ok!(command_encoder => instance.command_encoder_pop_debug_group(command_encoder)) gfx_ok!(command_encoder => instance.command_encoder_pop_debug_group(command_encoder))
@ -580,8 +569,7 @@ pub fn op_webgpu_command_encoder_insert_debug_marker(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
gfx_ok!(command_encoder => instance.command_encoder_insert_debug_marker( gfx_ok!(command_encoder => instance.command_encoder_insert_debug_marker(
@ -606,13 +594,11 @@ pub fn op_webgpu_command_encoder_write_timestamp(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let query_set_resource = state let query_set_resource = state
.resource_table .resource_table
.get::<super::WebGpuQuerySet>(args.query_set) .get::<super::WebGpuQuerySet>(args.query_set)?;
.ok_or_else(bad_resource_id)?;
gfx_ok!(command_encoder => instance.command_encoder_write_timestamp( gfx_ok!(command_encoder => instance.command_encoder_write_timestamp(
command_encoder, command_encoder,
@ -640,17 +626,14 @@ pub fn op_webgpu_command_encoder_resolve_query_set(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid) .get::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let query_set_resource = state let query_set_resource = state
.resource_table .resource_table
.get::<super::WebGpuQuerySet>(args.query_set) .get::<super::WebGpuQuerySet>(args.query_set)?;
.ok_or_else(bad_resource_id)?;
let destination_resource = state let destination_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.destination) .get::<super::buffer::WebGpuBuffer>(args.destination)?;
.ok_or_else(bad_resource_id)?;
gfx_ok!(command_encoder => instance.command_encoder_resolve_query_set( gfx_ok!(command_encoder => instance.command_encoder_resolve_query_set(
command_encoder, command_encoder,
@ -676,8 +659,7 @@ pub fn op_webgpu_command_encoder_finish(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.take::<WebGpuCommandEncoder>(args.command_encoder_rid) .take::<WebGpuCommandEncoder>(args.command_encoder_rid)?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();

64
ext/webgpu/compute_pass.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::ResourceId; use deno_core::ResourceId;
@ -33,14 +32,13 @@ pub fn op_webgpu_compute_pass_set_pipeline(
args: ComputePassSetPipelineArgs, args: ComputePassSetPipelineArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let compute_pipeline_resource = state let compute_pipeline_resource =
.resource_table state
.get::<super::pipeline::WebGpuComputePipeline>(args.pipeline) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::pipeline::WebGpuComputePipeline>(args.pipeline)?;
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::compute_ffi::wgpu_compute_pass_set_pipeline( wgpu_core::command::compute_ffi::wgpu_compute_pass_set_pipeline(
&mut compute_pass_resource.0.borrow_mut(), &mut compute_pass_resource.0.borrow_mut(),
@ -66,8 +64,7 @@ pub fn op_webgpu_compute_pass_dispatch(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::compute_ffi::wgpu_compute_pass_dispatch( wgpu_core::command::compute_ffi::wgpu_compute_pass_dispatch(
&mut compute_pass_resource.0.borrow_mut(), &mut compute_pass_resource.0.borrow_mut(),
@ -94,12 +91,10 @@ pub fn op_webgpu_compute_pass_dispatch_indirect(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.indirect_buffer) .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)?;
.ok_or_else(bad_resource_id)?;
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::compute_ffi::wgpu_compute_pass_dispatch_indirect( wgpu_core::command::compute_ffi::wgpu_compute_pass_dispatch_indirect(
&mut compute_pass_resource.0.borrow_mut(), &mut compute_pass_resource.0.borrow_mut(),
@ -125,12 +120,10 @@ pub fn op_webgpu_compute_pass_begin_pipeline_statistics_query(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
let query_set_resource = state let query_set_resource = state
.resource_table .resource_table
.get::<super::WebGpuQuerySet>(args.query_set) .get::<super::WebGpuQuerySet>(args.query_set)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::compute_ffi::wgpu_compute_pass_begin_pipeline_statistics_query( wgpu_core::command::compute_ffi::wgpu_compute_pass_begin_pipeline_statistics_query(
&mut compute_pass_resource.0.borrow_mut(), &mut compute_pass_resource.0.borrow_mut(),
@ -154,8 +147,7 @@ pub fn op_webgpu_compute_pass_end_pipeline_statistics_query(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::compute_ffi::wgpu_compute_pass_end_pipeline_statistics_query( wgpu_core::command::compute_ffi::wgpu_compute_pass_end_pipeline_statistics_query(
&mut compute_pass_resource.0.borrow_mut(), &mut compute_pass_resource.0.borrow_mut(),
@ -179,12 +171,10 @@ pub fn op_webgpu_compute_pass_write_timestamp(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
let query_set_resource = state let query_set_resource = state
.resource_table .resource_table
.get::<super::WebGpuQuerySet>(args.query_set) .get::<super::WebGpuQuerySet>(args.query_set)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::compute_ffi::wgpu_compute_pass_write_timestamp( wgpu_core::command::compute_ffi::wgpu_compute_pass_write_timestamp(
&mut compute_pass_resource.0.borrow_mut(), &mut compute_pass_resource.0.borrow_mut(),
@ -210,14 +200,12 @@ pub fn op_webgpu_compute_pass_end_pass(
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<super::command_encoder::WebGpuCommandEncoder>( .get::<super::command_encoder::WebGpuCommandEncoder>(
args.command_encoder_rid, args.command_encoder_rid,
) )?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.take::<WebGpuComputePass>(args.compute_pass_rid) .take::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
let compute_pass = &compute_pass_resource.0.borrow(); let compute_pass = &compute_pass_resource.0.borrow();
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
@ -243,14 +231,13 @@ pub fn op_webgpu_compute_pass_set_bind_group(
args: ComputePassSetBindGroupArgs, args: ComputePassSetBindGroupArgs,
zero_copy: Option<ZeroCopyBuf>, zero_copy: Option<ZeroCopyBuf>,
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let bind_group_resource = state let bind_group_resource =
.resource_table state
.get::<super::binding::WebGpuBindGroup>(args.bind_group) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::binding::WebGpuBindGroup>(args.bind_group)?;
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
unsafe { unsafe {
wgpu_core::command::compute_ffi::wgpu_compute_pass_set_bind_group( wgpu_core::command::compute_ffi::wgpu_compute_pass_set_bind_group(
@ -288,8 +275,7 @@ pub fn op_webgpu_compute_pass_push_debug_group(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
unsafe { unsafe {
let label = std::ffi::CString::new(args.group_label).unwrap(); let label = std::ffi::CString::new(args.group_label).unwrap();
@ -316,8 +302,7 @@ pub fn op_webgpu_compute_pass_pop_debug_group(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::compute_ffi::wgpu_compute_pass_pop_debug_group( wgpu_core::command::compute_ffi::wgpu_compute_pass_pop_debug_group(
&mut compute_pass_resource.0.borrow_mut(), &mut compute_pass_resource.0.borrow_mut(),
@ -340,8 +325,7 @@ pub fn op_webgpu_compute_pass_insert_debug_marker(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state let compute_pass_resource = state
.resource_table .resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid) .get::<WebGpuComputePass>(args.compute_pass_rid)?;
.ok_or_else(bad_resource_id)?;
unsafe { unsafe {
let label = std::ffi::CString::new(args.marker_label).unwrap(); let label = std::ffi::CString::new(args.marker_label).unwrap();

11
ext/webgpu/lib.rs
View file

@ -1,7 +1,7 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::not_supported;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::error::{bad_resource_id, not_supported};
use deno_core::include_js_files; use deno_core::include_js_files;
use deno_core::op_async; use deno_core::op_async;
use deno_core::op_sync; use deno_core::op_sync;
@ -398,8 +398,7 @@ pub async fn op_webgpu_request_device(
let mut state = state.borrow_mut(); let mut state = state.borrow_mut();
let adapter_resource = state let adapter_resource = state
.resource_table .resource_table
.get::<WebGpuAdapter>(args.adapter_rid) .get::<WebGpuAdapter>(args.adapter_rid)?;
.ok_or_else(bad_resource_id)?;
let adapter = adapter_resource.0; let adapter = adapter_resource.0;
let instance = state.borrow::<Instance>(); let instance = state.borrow::<Instance>();
@ -533,10 +532,8 @@ pub fn op_webgpu_create_query_set(
args: CreateQuerySetArgs, args: CreateQuerySetArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let device_resource = state let device_resource =
.resource_table state.resource_table.get::<WebGpuDevice>(args.device_rid)?;
.get::<WebGpuDevice>(args.device_rid)
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let instance = &state.borrow::<Instance>(); let instance = &state.borrow::<Instance>();

41
ext/webgpu/pipeline.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::ResourceId; use deno_core::ResourceId;
use deno_core::{OpState, Resource}; use deno_core::{OpState, Resource};
@ -173,24 +172,20 @@ pub fn op_webgpu_create_compute_pipeline(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let pipeline_layout = if let Some(rid) = args.layout { let pipeline_layout = if let Some(rid) = args.layout {
let id = state let id = state.resource_table.get::<WebGpuPipelineLayout>(rid)?;
.resource_table
.get::<WebGpuPipelineLayout>(rid)
.ok_or_else(bad_resource_id)?;
Some(id.0) Some(id.0)
} else { } else {
None None
}; };
let compute_shader_module_resource = state let compute_shader_module_resource =
.resource_table state
.get::<super::shader::WebGpuShaderModule>(args.compute.module) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::shader::WebGpuShaderModule>(args.compute.module)?;
let descriptor = wgpu_core::pipeline::ComputePipelineDescriptor { let descriptor = wgpu_core::pipeline::ComputePipelineDescriptor {
label: args.label.map(Cow::from), label: args.label.map(Cow::from),
@ -246,8 +241,7 @@ pub fn op_webgpu_compute_pipeline_get_bind_group_layout(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let compute_pipeline_resource = state let compute_pipeline_resource = state
.resource_table .resource_table
.get::<WebGpuComputePipeline>(args.compute_pipeline_rid) .get::<WebGpuComputePipeline>(args.compute_pipeline_rid)?;
.ok_or_else(bad_resource_id)?;
let compute_pipeline = compute_pipeline_resource.0; let compute_pipeline = compute_pipeline_resource.0;
let (bind_group_layout, maybe_err) = gfx_select!(compute_pipeline => instance.compute_pipeline_get_bind_group_layout(compute_pipeline, args.index, std::marker::PhantomData)); let (bind_group_layout, maybe_err) = gfx_select!(compute_pipeline => instance.compute_pipeline_get_bind_group_layout(compute_pipeline, args.index, std::marker::PhantomData));
@ -464,24 +458,21 @@ pub fn op_webgpu_create_render_pipeline(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let layout = if let Some(rid) = args.layout { let layout = if let Some(rid) = args.layout {
let pipeline_layout_resource = state let pipeline_layout_resource =
.resource_table state.resource_table.get::<WebGpuPipelineLayout>(rid)?;
.get::<WebGpuPipelineLayout>(rid)
.ok_or_else(bad_resource_id)?;
Some(pipeline_layout_resource.0) Some(pipeline_layout_resource.0)
} else { } else {
None None
}; };
let vertex_shader_module_resource = state let vertex_shader_module_resource =
.resource_table state
.get::<super::shader::WebGpuShaderModule>(args.vertex.module) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::shader::WebGpuShaderModule>(args.vertex.module)?;
let descriptor = wgpu_core::pipeline::RenderPipelineDescriptor { let descriptor = wgpu_core::pipeline::RenderPipelineDescriptor {
label: args.label.map(Cow::from), label: args.label.map(Cow::from),
@ -601,7 +592,6 @@ pub fn op_webgpu_create_render_pipeline(
let fragment_shader_module_resource = state let fragment_shader_module_resource = state
.resource_table .resource_table
.get::<super::shader::WebGpuShaderModule>(fragment.module) .get::<super::shader::WebGpuShaderModule>(fragment.module)
.ok_or_else(bad_resource_id)
.unwrap(); .unwrap();
wgpu_core::pipeline::FragmentState { wgpu_core::pipeline::FragmentState {
@ -666,8 +656,7 @@ pub fn op_webgpu_render_pipeline_get_bind_group_layout(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let render_pipeline_resource = state let render_pipeline_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPipeline>(args.render_pipeline_rid) .get::<WebGpuRenderPipeline>(args.render_pipeline_rid)?;
.ok_or_else(bad_resource_id)?;
let render_pipeline = render_pipeline_resource.0; let render_pipeline = render_pipeline_resource.0;
let (bind_group_layout, maybe_err) = gfx_select!(render_pipeline => instance.render_pipeline_get_bind_group_layout(render_pipeline, args.index, std::marker::PhantomData)); let (bind_group_layout, maybe_err) = gfx_select!(render_pipeline => instance.render_pipeline_get_bind_group_layout(render_pipeline, args.index, std::marker::PhantomData));

33
ext/webgpu/queue.rs
View file

@ -2,7 +2,6 @@
use std::num::NonZeroU32; use std::num::NonZeroU32;
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::OpState; use deno_core::OpState;
@ -27,19 +26,17 @@ pub fn op_webgpu_queue_submit(
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let queue_resource = state let queue_resource =
.resource_table state.resource_table.get::<WebGpuQueue>(args.queue_rid)?;
.get::<WebGpuQueue>(args.queue_rid)
.ok_or_else(bad_resource_id)?;
let queue = queue_resource.0; let queue = queue_resource.0;
let mut ids = vec![]; let mut ids = vec![];
for rid in args.command_buffers { for rid in args.command_buffers {
let buffer_resource = state let buffer_resource =
.resource_table state
.get::<super::command_encoder::WebGpuCommandBuffer>(rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::command_encoder::WebGpuCommandBuffer>(rid)?;
ids.push(buffer_resource.0); ids.push(buffer_resource.0);
} }
@ -76,13 +73,10 @@ pub fn op_webgpu_write_buffer(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer) .get::<super::buffer::WebGpuBuffer>(args.buffer)?;
.ok_or_else(bad_resource_id)?;
let buffer = buffer_resource.0; let buffer = buffer_resource.0;
let queue_resource = state let queue_resource =
.resource_table state.resource_table.get::<WebGpuQueue>(args.queue_rid)?;
.get::<WebGpuQueue>(args.queue_rid)
.ok_or_else(bad_resource_id)?;
let queue = queue_resource.0; let queue = queue_resource.0;
let data = match args.size { let data = match args.size {
@ -118,12 +112,9 @@ pub fn op_webgpu_write_texture(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let texture_resource = state let texture_resource = state
.resource_table .resource_table
.get::<super::texture::WebGpuTexture>(args.destination.texture) .get::<super::texture::WebGpuTexture>(args.destination.texture)?;
.ok_or_else(bad_resource_id)?; let queue_resource =
let queue_resource = state state.resource_table.get::<WebGpuQueue>(args.queue_rid)?;
.resource_table
.get::<WebGpuQueue>(args.queue_rid)
.ok_or_else(bad_resource_id)?;
let queue = queue_resource.0; let queue = queue_resource.0;
let destination = wgpu_core::command::ImageCopyTexture { let destination = wgpu_core::command::ImageCopyTexture {

108
ext/webgpu/render_pass.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::type_error; use deno_core::error::type_error;
use deno_core::error::AnyError; use deno_core::error::AnyError;
@ -41,8 +40,7 @@ pub fn op_webgpu_render_pass_set_viewport(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_set_viewport( wgpu_core::command::render_ffi::wgpu_render_pass_set_viewport(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -74,8 +72,7 @@ pub fn op_webgpu_render_pass_set_scissor_rect(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_set_scissor_rect( wgpu_core::command::render_ffi::wgpu_render_pass_set_scissor_rect(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -111,8 +108,7 @@ pub fn op_webgpu_render_pass_set_blend_constant(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_set_blend_constant( wgpu_core::command::render_ffi::wgpu_render_pass_set_blend_constant(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -141,8 +137,7 @@ pub fn op_webgpu_render_pass_set_stencil_reference(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_set_stencil_reference( wgpu_core::command::render_ffi::wgpu_render_pass_set_stencil_reference(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -167,12 +162,10 @@ pub fn op_webgpu_render_pass_begin_pipeline_statistics_query(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
let query_set_resource = state let query_set_resource = state
.resource_table .resource_table
.get::<super::WebGpuQuerySet>(args.query_set) .get::<super::WebGpuQuerySet>(args.query_set)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_begin_pipeline_statistics_query( wgpu_core::command::render_ffi::wgpu_render_pass_begin_pipeline_statistics_query(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -196,8 +189,7 @@ pub fn op_webgpu_render_pass_end_pipeline_statistics_query(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_end_pipeline_statistics_query( wgpu_core::command::render_ffi::wgpu_render_pass_end_pipeline_statistics_query(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -221,12 +213,10 @@ pub fn op_webgpu_render_pass_write_timestamp(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
let query_set_resource = state let query_set_resource = state
.resource_table .resource_table
.get::<super::WebGpuQuerySet>(args.query_set) .get::<super::WebGpuQuerySet>(args.query_set)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_write_timestamp( wgpu_core::command::render_ffi::wgpu_render_pass_write_timestamp(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -252,17 +242,16 @@ pub fn op_webgpu_render_pass_execute_bundles(
let mut render_bundle_ids = vec![]; let mut render_bundle_ids = vec![];
for rid in &args.bundles { for rid in &args.bundles {
let render_bundle_resource = state let render_bundle_resource =
.resource_table state
.get::<super::bundle::WebGpuRenderBundle>(*rid) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::bundle::WebGpuRenderBundle>(*rid)?;
render_bundle_ids.push(render_bundle_resource.0); render_bundle_ids.push(render_bundle_resource.0);
} }
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
unsafe { unsafe {
wgpu_core::command::render_ffi::wgpu_render_pass_execute_bundles( wgpu_core::command::render_ffi::wgpu_render_pass_execute_bundles(
@ -290,14 +279,12 @@ pub fn op_webgpu_render_pass_end_pass(
let command_encoder_resource = state let command_encoder_resource = state
.resource_table .resource_table
.get::<super::command_encoder::WebGpuCommandEncoder>( .get::<super::command_encoder::WebGpuCommandEncoder>(
args.command_encoder_rid, args.command_encoder_rid,
) )?;
.ok_or_else(bad_resource_id)?;
let command_encoder = command_encoder_resource.0; let command_encoder = command_encoder_resource.0;
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.take::<WebGpuRenderPass>(args.render_pass_rid) .take::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
let render_pass = &render_pass_resource.0.borrow(); let render_pass = &render_pass_resource.0.borrow();
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
@ -320,14 +307,13 @@ pub fn op_webgpu_render_pass_set_bind_group(
args: RenderPassSetBindGroupArgs, args: RenderPassSetBindGroupArgs,
zero_copy: Option<ZeroCopyBuf>, zero_copy: Option<ZeroCopyBuf>,
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let bind_group_resource = state let bind_group_resource =
.resource_table state
.get::<super::binding::WebGpuBindGroup>(args.bind_group) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::binding::WebGpuBindGroup>(args.bind_group)?;
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
// I know this might look like it can be easily deduplicated, but it can not // I know this might look like it can be easily deduplicated, but it can not
// be due to the lifetime of the args.dynamic_offsets_data slice. Because we // be due to the lifetime of the args.dynamic_offsets_data slice. Because we
@ -378,8 +364,7 @@ pub fn op_webgpu_render_pass_push_debug_group(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
unsafe { unsafe {
let label = std::ffi::CString::new(args.group_label).unwrap(); let label = std::ffi::CString::new(args.group_label).unwrap();
@ -406,8 +391,7 @@ pub fn op_webgpu_render_pass_pop_debug_group(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_pop_debug_group( wgpu_core::command::render_ffi::wgpu_render_pass_pop_debug_group(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -430,8 +414,7 @@ pub fn op_webgpu_render_pass_insert_debug_marker(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
unsafe { unsafe {
let label = std::ffi::CString::new(args.marker_label).unwrap(); let label = std::ffi::CString::new(args.marker_label).unwrap();
@ -457,14 +440,13 @@ pub fn op_webgpu_render_pass_set_pipeline(
args: RenderPassSetPipelineArgs, args: RenderPassSetPipelineArgs,
_: (), _: (),
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pipeline_resource = state let render_pipeline_resource =
.resource_table state
.get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline) .resource_table
.ok_or_else(bad_resource_id)?; .get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)?;
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_set_pipeline( wgpu_core::command::render_ffi::wgpu_render_pass_set_pipeline(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -491,12 +473,10 @@ pub fn op_webgpu_render_pass_set_index_buffer(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer) .get::<super::buffer::WebGpuBuffer>(args.buffer)?;
.ok_or_else(bad_resource_id)?;
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
let size = if let Some(size) = args.size { let size = if let Some(size) = args.size {
Some( Some(
@ -534,12 +514,10 @@ pub fn op_webgpu_render_pass_set_vertex_buffer(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer) .get::<super::buffer::WebGpuBuffer>(args.buffer)?;
.ok_or_else(bad_resource_id)?;
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
let size = if let Some(size) = args.size { let size = if let Some(size) = args.size {
Some( Some(
@ -578,8 +556,7 @@ pub fn op_webgpu_render_pass_draw(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_draw( wgpu_core::command::render_ffi::wgpu_render_pass_draw(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -610,8 +587,7 @@ pub fn op_webgpu_render_pass_draw_indexed(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_draw_indexed( wgpu_core::command::render_ffi::wgpu_render_pass_draw_indexed(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -640,12 +616,10 @@ pub fn op_webgpu_render_pass_draw_indirect(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.indirect_buffer) .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)?;
.ok_or_else(bad_resource_id)?;
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_draw_indirect( wgpu_core::command::render_ffi::wgpu_render_pass_draw_indirect(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),
@ -671,12 +645,10 @@ pub fn op_webgpu_render_pass_draw_indexed_indirect(
) -> Result<WebGpuResult, AnyError> { ) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state let buffer_resource = state
.resource_table .resource_table
.get::<super::buffer::WebGpuBuffer>(args.indirect_buffer) .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)?;
.ok_or_else(bad_resource_id)?;
let render_pass_resource = state let render_pass_resource = state
.resource_table .resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid) .get::<WebGpuRenderPass>(args.render_pass_rid)?;
.ok_or_else(bad_resource_id)?;
wgpu_core::command::render_ffi::wgpu_render_pass_draw_indexed_indirect( wgpu_core::command::render_ffi::wgpu_render_pass_draw_indexed_indirect(
&mut render_pass_resource.0.borrow_mut(), &mut render_pass_resource.0.borrow_mut(),

4
ext/webgpu/sampler.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::ResourceId; use deno_core::ResourceId;
use deno_core::{OpState, Resource}; use deno_core::{OpState, Resource};
@ -84,8 +83,7 @@ pub fn op_webgpu_create_sampler(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let descriptor = wgpu_core::resource::SamplerDescriptor { let descriptor = wgpu_core::resource::SamplerDescriptor {

4
ext/webgpu/shader.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::ResourceId; use deno_core::ResourceId;
@ -35,8 +34,7 @@ pub fn op_webgpu_create_shader_module(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let source = match args.code { let source = match args.code {

8
ext/webgpu/texture.rs
View file

@ -1,7 +1,7 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::not_supported;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::error::{bad_resource_id, not_supported};
use deno_core::ResourceId; use deno_core::ResourceId;
use deno_core::{OpState, Resource}; use deno_core::{OpState, Resource};
use serde::Deserialize; use serde::Deserialize;
@ -149,8 +149,7 @@ pub fn op_webgpu_create_texture(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let device_resource = state let device_resource = state
.resource_table .resource_table
.get::<super::WebGpuDevice>(args.device_rid) .get::<super::WebGpuDevice>(args.device_rid)?;
.ok_or_else(bad_resource_id)?;
let device = device_resource.0; let device = device_resource.0;
let descriptor = wgpu_core::resource::TextureDescriptor { let descriptor = wgpu_core::resource::TextureDescriptor {
@ -204,8 +203,7 @@ pub fn op_webgpu_create_texture_view(
let instance = state.borrow::<super::Instance>(); let instance = state.borrow::<super::Instance>();
let texture_resource = state let texture_resource = state
.resource_table .resource_table
.get::<WebGpuTexture>(args.texture_rid) .get::<WebGpuTexture>(args.texture_rid)?;
.ok_or_else(bad_resource_id)?;
let texture = texture_resource.0; let texture = texture_resource.0;
let descriptor = wgpu_core::resource::TextureViewDescriptor { let descriptor = wgpu_core::resource::TextureViewDescriptor {

15
ext/websocket/lib.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::bad_resource_id;
use deno_core::error::invalid_hostname; use deno_core::error::invalid_hostname;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::AnyError; use deno_core::error::AnyError;
@ -272,8 +271,7 @@ where
let r = state let r = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<WsCancelResource>(cancel_rid) .get::<WsCancelResource>(cancel_rid)?;
.ok_or_else(bad_resource_id)?;
client client
.or_cancel(r.0.to_owned()) .or_cancel(r.0.to_owned())
.await .await
@ -289,7 +287,7 @@ where
})?; })?;
if let Some(cancel_rid) = args.cancel_handle { if let Some(cancel_rid) = args.cancel_handle {
state.borrow_mut().resource_table.close(cancel_rid); state.borrow_mut().resource_table.close(cancel_rid).ok();
} }
let (ws_tx, ws_rx) = stream.split(); let (ws_tx, ws_rx) = stream.split();
@ -343,8 +341,7 @@ pub async fn op_ws_send(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<WsStreamResource>(args.rid) .get::<WsStreamResource>(args.rid)?;
.ok_or_else(bad_resource_id)?;
resource.send(msg).await?; resource.send(msg).await?;
Ok(()) Ok(())
} }
@ -374,8 +371,7 @@ pub async fn op_ws_close(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<WsStreamResource>(rid) .get::<WsStreamResource>(rid)?;
.ok_or_else(bad_resource_id)?;
resource.send(msg).await?; resource.send(msg).await?;
Ok(()) Ok(())
} }
@ -400,8 +396,7 @@ pub async fn op_ws_next_event(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<WsStreamResource>(rid) .get::<WsStreamResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let cancel = RcRef::map(&resource, |r| &r.cancel); let cancel = RcRef::map(&resource, |r| &r.cancel);
let val = resource.next_message(cancel).await?; let val = resource.next_message(cancel).await?;

18
runtime/ops/fs.rs
View file

@ -230,8 +230,7 @@ async fn op_seek_async(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<StdFileResource>(rid) .get::<StdFileResource>(rid)?;
.ok_or_else(bad_resource_id)?;
if resource.fs_file.is_none() { if resource.fs_file.is_none() {
return Err(bad_resource_id()); return Err(bad_resource_id());
@ -265,8 +264,7 @@ async fn op_fdatasync_async(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<StdFileResource>(rid) .get::<StdFileResource>(rid)?;
.ok_or_else(bad_resource_id)?;
if resource.fs_file.is_none() { if resource.fs_file.is_none() {
return Err(bad_resource_id()); return Err(bad_resource_id());
@ -300,8 +298,7 @@ async fn op_fsync_async(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<StdFileResource>(rid) .get::<StdFileResource>(rid)?;
.ok_or_else(bad_resource_id)?;
if resource.fs_file.is_none() { if resource.fs_file.is_none() {
return Err(bad_resource_id()); return Err(bad_resource_id());
@ -335,8 +332,7 @@ async fn op_fstat_async(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<StdFileResource>(rid) .get::<StdFileResource>(rid)?;
.ok_or_else(bad_resource_id)?;
if resource.fs_file.is_none() { if resource.fs_file.is_none() {
return Err(bad_resource_id()); return Err(bad_resource_id());
@ -1298,8 +1294,7 @@ async fn op_ftruncate_async(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<StdFileResource>(rid) .get::<StdFileResource>(rid)?;
.ok_or_else(bad_resource_id)?;
if resource.fs_file.is_none() { if resource.fs_file.is_none() {
return Err(bad_resource_id()); return Err(bad_resource_id());
@ -1580,8 +1575,7 @@ async fn op_futime_async(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<StdFileResource>(rid) .get::<StdFileResource>(rid)?;
.ok_or_else(bad_resource_id)?;
if resource.fs_file.is_none() { if resource.fs_file.is_none() {
return Err(bad_resource_id()); return Err(bad_resource_id());

7
runtime/ops/fs_events.rs
View file

@ -1,7 +1,6 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use crate::permissions::Permissions; use crate::permissions::Permissions;
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex; use deno_core::parking_lot::Mutex;
use deno_core::AsyncRefCell; use deno_core::AsyncRefCell;
@ -135,11 +134,7 @@ async fn op_fs_events_poll(
rid: ResourceId, rid: ResourceId,
_: (), _: (),
) -> Result<Option<FsEvent>, AnyError> { ) -> Result<Option<FsEvent>, AnyError> {
let resource = state let resource = state.borrow().resource_table.get::<FsEventsResource>(rid)?;
.borrow()
.resource_table
.get::<FsEventsResource>(rid)
.ok_or_else(bad_resource_id)?;
let mut receiver = RcRef::map(&resource, |r| &r.receiver).borrow_mut().await; let mut receiver = RcRef::map(&resource, |r| &r.receiver).borrow_mut().await;
let cancel = RcRef::map(resource, |r| &r.cancel); let cancel = RcRef::map(resource, |r| &r.cancel);
let maybe_result = receiver.recv().or_cancel(cancel).await?; let maybe_result = receiver.recv().or_cancel(cancel).await?;

4
runtime/ops/http.rs
View file

@ -20,7 +20,7 @@ fn op_http_start(
tcp_stream_rid: ResourceId, tcp_stream_rid: ResourceId,
_: (), _: (),
) -> Result<ResourceId, AnyError> { ) -> Result<ResourceId, AnyError> {
if let Some(resource_rc) = state if let Ok(resource_rc) = state
.resource_table .resource_table
.take::<TcpStreamResource>(tcp_stream_rid) .take::<TcpStreamResource>(tcp_stream_rid)
{ {
@ -32,7 +32,7 @@ fn op_http_start(
return deno_http::start_http(state, tcp_stream, addr, "http"); return deno_http::start_http(state, tcp_stream, addr, "http");
} }
if let Some(resource_rc) = state if let Ok(resource_rc) = state
.resource_table .resource_table
.take::<TlsStreamResource>(tcp_stream_rid) .take::<TlsStreamResource>(tcp_stream_rid)
{ {

25
runtime/ops/io.rs
View file

@ -1,9 +1,9 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::not_supported;
use deno_core::error::null_opbuf; use deno_core::error::null_opbuf;
use deno_core::error::resource_unavailable; use deno_core::error::resource_unavailable;
use deno_core::error::AnyError; use deno_core::error::AnyError;
use deno_core::error::{bad_resource_id, not_supported};
use deno_core::op_async; use deno_core::op_async;
use deno_core::op_sync; use deno_core::op_sync;
use deno_core::AsyncMutFuture; use deno_core::AsyncMutFuture;
@ -334,10 +334,7 @@ impl StdFileResource {
F: FnMut(Result<&mut std::fs::File, ()>) -> Result<R, AnyError>, F: FnMut(Result<&mut std::fs::File, ()>) -> Result<R, AnyError>,
{ {
// First we look up the rid in the resource table. // First we look up the rid in the resource table.
let resource = state let resource = state.resource_table.get::<StdFileResource>(rid)?;
.resource_table
.get::<StdFileResource>(rid)
.ok_or_else(bad_resource_id)?;
// Sync write only works for FsFile. It doesn't make sense to do this // Sync write only works for FsFile. It doesn't make sense to do this
// for non-blocking sockets. So we error out if not FsFile. // for non-blocking sockets. So we error out if not FsFile.
@ -408,11 +405,7 @@ async fn op_read_async(
buf: Option<ZeroCopyBuf>, buf: Option<ZeroCopyBuf>,
) -> Result<u32, AnyError> { ) -> Result<u32, AnyError> {
let buf = &mut buf.ok_or_else(null_opbuf)?; let buf = &mut buf.ok_or_else(null_opbuf)?;
let resource = state let resource = state.borrow().resource_table.get_any(rid)?;
.borrow()
.resource_table
.get_any(rid)
.ok_or_else(bad_resource_id)?;
let nread = if let Some(s) = resource.downcast_rc::<ChildStdoutResource>() { let nread = if let Some(s) = resource.downcast_rc::<ChildStdoutResource>() {
s.read(buf).await? s.read(buf).await?
} else if let Some(s) = resource.downcast_rc::<ChildStderrResource>() { } else if let Some(s) = resource.downcast_rc::<ChildStderrResource>() {
@ -452,11 +445,7 @@ async fn op_write_async(
buf: Option<ZeroCopyBuf>, buf: Option<ZeroCopyBuf>,
) -> Result<u32, AnyError> { ) -> Result<u32, AnyError> {
let buf = &buf.ok_or_else(null_opbuf)?; let buf = &buf.ok_or_else(null_opbuf)?;
let resource = state let resource = state.borrow().resource_table.get_any(rid)?;
.borrow()
.resource_table
.get_any(rid)
.ok_or_else(bad_resource_id)?;
let nwritten = if let Some(s) = resource.downcast_rc::<ChildStdinResource>() { let nwritten = if let Some(s) = resource.downcast_rc::<ChildStdinResource>() {
s.write(buf).await? s.write(buf).await?
} else if let Some(s) = resource.downcast_rc::<TcpStreamResource>() { } else if let Some(s) = resource.downcast_rc::<TcpStreamResource>() {
@ -478,11 +467,7 @@ async fn op_shutdown(
rid: ResourceId, rid: ResourceId,
_: (), _: (),
) -> Result<(), AnyError> { ) -> Result<(), AnyError> {
let resource = state let resource = state.borrow().resource_table.get_any(rid)?;
.borrow()
.resource_table
.get_any(rid)
.ok_or_else(bad_resource_id)?;
if let Some(s) = resource.downcast_rc::<ChildStdinResource>() { if let Some(s) = resource.downcast_rc::<ChildStdinResource>() {
s.shutdown().await?; s.shutdown().await?;
} else if let Some(s) = resource.downcast_rc::<TcpStreamResource>() { } else if let Some(s) = resource.downcast_rc::<TcpStreamResource>() {

3
runtime/ops/process.rs
View file

@ -212,8 +212,7 @@ async fn op_run_status(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<ChildResource>(rid) .get::<ChildResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let mut child = resource.borrow_mut().await; let mut child = resource.borrow_mut().await;
let run_status = child.wait().await?; let run_status = child.wait().await?;
let code = run_status.code(); let code = run_status.code();

10
runtime/ops/signal.rs
View file

@ -7,8 +7,6 @@ use deno_core::OpState;
use std::cell::RefCell; use std::cell::RefCell;
use std::rc::Rc; use std::rc::Rc;
#[cfg(unix)]
use deno_core::error::bad_resource_id;
#[cfg(unix)] #[cfg(unix)]
use deno_core::AsyncRefCell; use deno_core::AsyncRefCell;
#[cfg(unix)] #[cfg(unix)]
@ -81,8 +79,7 @@ async fn op_signal_poll(
let resource = state let resource = state
.borrow_mut() .borrow_mut()
.resource_table .resource_table
.get::<SignalStreamResource>(rid) .get::<SignalStreamResource>(rid)?;
.ok_or_else(bad_resource_id)?;
let cancel = RcRef::map(&resource, |r| &r.cancel); let cancel = RcRef::map(&resource, |r| &r.cancel);
let mut signal = RcRef::map(&resource, |r| &r.signal).borrow_mut().await; let mut signal = RcRef::map(&resource, |r| &r.signal).borrow_mut().await;
@ -99,10 +96,7 @@ pub fn op_signal_unbind(
_: (), _: (),
) -> Result<(), AnyError> { ) -> Result<(), AnyError> {
super::check_unstable(state, "Deno.signal"); super::check_unstable(state, "Deno.signal");
state state.resource_table.close(rid)?;
.resource_table
.close(rid)
.ok_or_else(bad_resource_id)?;
Ok(()) Ok(())
} }

10
runtime/ops/tty.rs
View file

@ -89,10 +89,7 @@ fn op_set_raw(
use winapi::shared::minwindef::FALSE; use winapi::shared::minwindef::FALSE;
use winapi::um::{consoleapi, handleapi}; use winapi::um::{consoleapi, handleapi};
let resource = state let resource = state.resource_table.get::<StdFileResource>(rid)?;
.resource_table
.get::<StdFileResource>(rid)
.ok_or_else(bad_resource_id)?;
if cbreak { if cbreak {
return Err(not_supported()); return Err(not_supported());
@ -156,10 +153,7 @@ fn op_set_raw(
{ {
use std::os::unix::io::AsRawFd; use std::os::unix::io::AsRawFd;
let resource = state let resource = state.resource_table.get::<StdFileResource>(rid)?;
.resource_table
.get::<StdFileResource>(rid)
.ok_or_else(bad_resource_id)?;
if resource.fs_file.is_none() { if resource.fs_file.is_none() {
return Err(not_supported()); return Err(not_supported());