summaryrefslogtreecommitdiff
path: root/op_crates
diff options
context:
space:
mode:
Diffstat (limited to 'op_crates')
-rw-r--r--op_crates/crypto/01_crypto.js2
-rw-r--r--op_crates/crypto/lib.rs8
-rw-r--r--op_crates/fetch/26_fetch.js22
-rw-r--r--op_crates/fetch/lib.rs82
-rw-r--r--op_crates/url/lib.rs68
-rw-r--r--op_crates/webgpu/binding.rs25
-rw-r--r--op_crates/webgpu/buffer.rs25
-rw-r--r--op_crates/webgpu/bundle.rs58
-rw-r--r--op_crates/webgpu/command_encoder.rs66
-rw-r--r--op_crates/webgpu/compute_pass.rs48
-rw-r--r--op_crates/webgpu/error.rs41
-rw-r--r--op_crates/webgpu/lib.rs86
-rw-r--r--op_crates/webgpu/pipeline.rs51
-rw-r--r--op_crates/webgpu/queue.rs16
-rw-r--r--op_crates/webgpu/render_pass.rs84
-rw-r--r--op_crates/webgpu/sampler.rs11
-rw-r--r--op_crates/webgpu/shader.rs11
-rw-r--r--op_crates/webgpu/texture.rs18
-rw-r--r--op_crates/websocket/01_websocket.js6
-rw-r--r--op_crates/websocket/lib.rs34
20 files changed, 356 insertions, 406 deletions
diff --git a/op_crates/crypto/01_crypto.js b/op_crates/crypto/01_crypto.js
index ce13dc74c..f0cb1d823 100644
--- a/op_crates/crypto/01_crypto.js
+++ b/op_crates/crypto/01_crypto.js
@@ -37,7 +37,7 @@
arrayBufferView.byteOffset,
arrayBufferView.byteLength,
);
- core.jsonOpSync("op_crypto_get_random_values", {}, ui8);
+ core.jsonOpSync("op_crypto_get_random_values", null, ui8);
return arrayBufferView;
}
diff --git a/op_crates/crypto/lib.rs b/op_crates/crypto/lib.rs
index 9fc61d871..c74b1b2c2 100644
--- a/op_crates/crypto/lib.rs
+++ b/op_crates/crypto/lib.rs
@@ -4,8 +4,6 @@
use deno_core::error::null_opbuf;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::JsRuntime;
use deno_core::OpState;
use deno_core::ZeroCopyBuf;
@@ -29,9 +27,9 @@ pub fn init(isolate: &mut JsRuntime) {
pub fn op_crypto_get_random_values(
state: &mut OpState,
- _args: Value,
+ _args: (),
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<(), AnyError> {
let mut zero_copy = zero_copy.ok_or_else(null_opbuf)?;
let maybe_seeded_rng = state.try_borrow_mut::<StdRng>();
if let Some(seeded_rng) = maybe_seeded_rng {
@@ -41,7 +39,7 @@ pub fn op_crypto_get_random_values(
rng.fill(&mut *zero_copy);
}
- Ok(json!({}))
+ Ok(())
}
pub fn get_declaration() -> PathBuf {
diff --git a/op_crates/fetch/26_fetch.js b/op_crates/fetch/26_fetch.js
index d4b2680ec..0fd825e16 100644
--- a/op_crates/fetch/26_fetch.js
+++ b/op_crates/fetch/26_fetch.js
@@ -884,29 +884,29 @@
if (body != null) {
zeroCopy = new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
}
- return core.jsonOpSync("op_fetch", args, ...(zeroCopy ? [zeroCopy] : []));
+ return core.jsonOpSync("op_fetch", args, zeroCopy);
}
/**
- * @param {{rid: number}} args
+ * @param {number} rid
* @returns {Promise<{status: number, statusText: string, headers: Record<string,string[]>, url: string, responseRid: number}>}
*/
- function opFetchSend(args) {
- return core.jsonOpAsync("op_fetch_send", args);
+ function opFetchSend(rid) {
+ return core.jsonOpAsync("op_fetch_send", rid);
}
/**
- * @param {{rid: number}} args
+ * @param {number} rid
* @param {Uint8Array} body
* @returns {Promise<void>}
*/
- function opFetchRequestWrite(args, body) {
+ function opFetchRequestWrite(rid, body) {
const zeroCopy = new Uint8Array(
body.buffer,
body.byteOffset,
body.byteLength,
);
- return core.jsonOpAsync("op_fetch_request_write", args, zeroCopy);
+ return core.jsonOpAsync("op_fetch_request_write", rid, zeroCopy);
}
const NULL_BODY_STATUS = [101, 204, 205, 304];
@@ -1276,7 +1276,7 @@
*/
async write(chunk, controller) {
try {
- await opFetchRequestWrite({ rid: requestBodyRid }, chunk);
+ await opFetchRequestWrite(requestBodyRid, chunk);
} catch (err) {
controller.error(err);
}
@@ -1288,7 +1288,7 @@
body.pipeTo(writer);
}
- return await opFetchSend({ rid: requestRid });
+ return await opFetchSend(requestRid);
}
/**
@@ -1400,9 +1400,9 @@
async pull(controller) {
try {
const chunk = new Uint8Array(16 * 1024 + 256);
- const { read } = await core.jsonOpAsync(
+ const read = await core.jsonOpAsync(
"op_fetch_response_read",
- { rid },
+ rid,
chunk,
);
if (read != 0) {
diff --git a/op_crates/fetch/lib.rs b/op_crates/fetch/lib.rs
index 19f2566c4..1d36bfc09 100644
--- a/op_crates/fetch/lib.rs
+++ b/op_crates/fetch/lib.rs
@@ -10,8 +10,6 @@ use deno_core::error::AnyError;
use deno_core::futures::Future;
use deno_core::futures::Stream;
use deno_core::futures::StreamExt;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::url::Url;
use deno_core::AsyncRefCell;
use deno_core::CancelFuture;
@@ -34,6 +32,7 @@ use reqwest::Client;
use reqwest::Method;
use reqwest::Response;
use serde::Deserialize;
+use serde::Serialize;
use std::borrow::Cow;
use std::cell::RefCell;
use std::convert::From;
@@ -121,11 +120,18 @@ pub struct FetchArgs {
has_body: bool,
}
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FetchReturn {
+ request_rid: ResourceId,
+ request_body_rid: Option<ResourceId>,
+}
+
pub fn op_fetch<FP>(
state: &mut OpState,
args: FetchArgs,
data: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError>
+) -> Result<FetchReturn, AnyError>
where
FP: FetchPermissions + 'static,
{
@@ -164,7 +170,7 @@ where
let mut request = client.request(method, url);
- let maybe_request_body_rid = if args.has_body {
+ let request_body_rid = if args.has_body {
match data {
None => {
// If no body is passed, we return a writer for streaming the body.
@@ -201,27 +207,31 @@ where
.resource_table
.add(FetchRequestResource(Box::pin(fut)));
- Ok(json!({
- "requestRid": request_rid,
- "requestBodyRid": maybe_request_body_rid
- }))
+ Ok(FetchReturn {
+ request_rid,
+ request_body_rid,
+ })
}
-#[derive(Deserialize)]
+#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
-pub struct FetchSendArgs {
- rid: ResourceId,
+pub struct FetchResponse {
+ status: u16,
+ status_text: String,
+ headers: Vec<(String, String)>,
+ url: String,
+ response_rid: ResourceId,
}
pub async fn op_fetch_send(
state: Rc<RefCell<OpState>>,
- args: FetchSendArgs,
+ rid: ResourceId,
_data: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<FetchResponse, AnyError> {
let request = state
.borrow_mut()
.resource_table
- .take::<FetchRequestResource>(args.rid)
+ .take::<FetchRequestResource>(rid)
.ok_or_else(bad_resource_id)?;
let request = Rc::try_unwrap(request)
@@ -266,27 +276,20 @@ pub async fn op_fetch_send(
cancel: CancelHandle::default(),
});
- Ok(json!({
- "status": status.as_u16(),
- "statusText": status.canonical_reason().unwrap_or(""),
- "headers": res_headers,
- "url": url,
- "responseRid": rid,
- }))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FetchRequestWriteArgs {
- rid: ResourceId,
+ Ok(FetchResponse {
+ status: status.as_u16(),
+ status_text: status.canonical_reason().unwrap_or("").to_string(),
+ headers: res_headers,
+ url,
+ response_rid: rid,
+ })
}
pub async fn op_fetch_request_write(
state: Rc<RefCell<OpState>>,
- args: FetchRequestWriteArgs,
+ rid: ResourceId,
data: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
- let rid = args.rid;
+) -> Result<(), AnyError> {
let data = data.ok_or_else(null_opbuf)?;
let buf = Vec::from(&*data);
@@ -299,21 +302,14 @@ pub async fn op_fetch_request_write(
let cancel = RcRef::map(resource, |r| &r.cancel);
body.send(Ok(buf)).or_cancel(cancel).await??;
- Ok(json!({}))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FetchResponseReadArgs {
- rid: ResourceId,
+ Ok(())
}
pub async fn op_fetch_response_read(
state: Rc<RefCell<OpState>>,
- args: FetchResponseReadArgs,
+ rid: ResourceId,
data: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
- let rid = args.rid;
+) -> Result<usize, AnyError> {
let data = data.ok_or_else(null_opbuf)?;
let resource = state
@@ -325,7 +321,7 @@ pub async fn op_fetch_response_read(
let cancel = RcRef::map(resource, |r| &r.cancel);
let mut buf = data.clone();
let read = reader.read(&mut buf).try_or_cancel(cancel).await?;
- Ok(json!({ "read": read }))
+ Ok(read)
}
struct FetchRequestResource(
@@ -391,7 +387,7 @@ pub fn op_create_http_client<FP>(
state: &mut OpState,
args: CreateHttpClientOptions,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError>
+) -> Result<ResourceId, AnyError>
where
FP: FetchPermissions + 'static,
{
@@ -411,7 +407,7 @@ where
.unwrap();
let rid = state.resource_table.add(HttpClientResource::new(client));
- Ok(json!(rid))
+ Ok(rid)
}
fn get_cert_data(
diff --git a/op_crates/url/lib.rs b/op_crates/url/lib.rs
index f7615725f..f216768c3 100644
--- a/op_crates/url/lib.rs
+++ b/op_crates/url/lib.rs
@@ -4,8 +4,6 @@ use deno_core::error::generic_error;
use deno_core::error::type_error;
use deno_core::error::uri_error;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::url::form_urlencoded;
use deno_core::url::quirks;
use deno_core::url::Url;
@@ -34,13 +32,28 @@ pub struct UrlParseArgs {
set_username: Option<String>,
}
+#[derive(Serialize)]
+pub struct UrlParts {
+ href: String,
+ hash: String,
+ host: String,
+ hostname: String,
+ origin: String,
+ password: String,
+ pathname: String,
+ port: String,
+ protocol: String,
+ search: String,
+ username: String,
+}
+
/// Parse `UrlParseArgs::href` with an optional `UrlParseArgs::base_href`, or an
/// optional part to "set" after parsing. Return `UrlParts`.
pub fn op_url_parse(
_state: &mut deno_core::OpState,
args: UrlParseArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<UrlParts, AnyError> {
let base_url = args
.base_href
.as_ref()
@@ -75,20 +88,6 @@ pub fn op_url_parse(
.map_err(|_| uri_error("Invalid username"))?;
}
- #[derive(Serialize)]
- struct UrlParts<'a> {
- href: &'a str,
- hash: &'a str,
- host: &'a str,
- hostname: &'a str,
- origin: &'a str,
- password: &'a str,
- pathname: &'a str,
- port: &'a str,
- protocol: &'a str,
- search: &'a str,
- username: &'a str,
- }
// TODO(nayeemrmn): Panic that occurs in rust-url for the `non-spec:`
// url-constructor wpt tests: https://github.com/servo/rust-url/issues/670.
let username = catch_unwind(|| quirks::username(&url)).map_err(|_| {
@@ -102,41 +101,42 @@ pub fn op_url_parse(
.unwrap_or_default()
))
})?;
- Ok(json!(UrlParts {
- href: quirks::href(&url),
- hash: quirks::hash(&url),
- host: quirks::host(&url),
- hostname: quirks::hostname(&url),
- origin: &quirks::origin(&url),
- password: quirks::password(&url),
- pathname: quirks::pathname(&url),
- port: quirks::port(&url),
- protocol: quirks::protocol(&url),
- search: quirks::search(&url),
- username,
- }))
+ Ok(UrlParts {
+ href: quirks::href(&url).to_string(),
+ hash: quirks::hash(&url).to_string(),
+ host: quirks::host(&url).to_string(),
+ hostname: quirks::hostname(&url).to_string(),
+ origin: quirks::origin(&url),
+ password: quirks::password(&url).to_string(),
+ pathname: quirks::pathname(&url).to_string(),
+ port: quirks::port(&url).to_string(),
+ protocol: quirks::protocol(&url).to_string(),
+ search: quirks::search(&url).to_string(),
+ username: username.to_string(),
+ })
}
pub fn op_url_parse_search_params(
_state: &mut deno_core::OpState,
args: String,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<Vec<(String, String)>, AnyError> {
let search_params: Vec<_> = form_urlencoded::parse(args.as_bytes())
.into_iter()
+ .map(|(k, v)| (k.as_ref().to_owned(), v.as_ref().to_owned()))
.collect();
- Ok(json!(search_params))
+ Ok(search_params)
}
pub fn op_url_stringify_search_params(
_state: &mut deno_core::OpState,
args: Vec<(String, String)>,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<String, AnyError> {
let search = form_urlencoded::Serializer::new(String::new())
.extend_pairs(args)
.finish();
- Ok(json!(search))
+ Ok(search)
}
/// Load and execute the javascript code.
diff --git a/op_crates/webgpu/binding.rs b/op_crates/webgpu/binding.rs
index 296a968f1..fd4e75784 100644
--- a/op_crates/webgpu/binding.rs
+++ b/op_crates/webgpu/binding.rs
@@ -2,15 +2,13 @@
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
use serde::Deserialize;
use std::borrow::Cow;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
pub(crate) struct WebGpuBindGroupLayout(
pub(crate) wgpu_core::id::BindGroupLayoutId,
@@ -83,7 +81,7 @@ pub fn op_webgpu_create_bind_group_layout(
state: &mut OpState,
args: CreateBindGroupLayoutArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -207,10 +205,7 @@ pub fn op_webgpu_create_bind_group_layout(
.resource_table
.add(WebGpuBindGroupLayout(bind_group_layout));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -225,7 +220,7 @@ pub fn op_webgpu_create_pipeline_layout(
state: &mut OpState,
args: CreatePipelineLayoutArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -259,10 +254,7 @@ pub fn op_webgpu_create_pipeline_layout(
.resource_table
.add(super::pipeline::WebGpuPipelineLayout(pipeline_layout));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -288,7 +280,7 @@ pub fn op_webgpu_create_bind_group(
state: &mut OpState,
args: CreateBindGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -356,8 +348,5 @@ pub fn op_webgpu_create_bind_group(
let rid = state.resource_table.add(WebGpuBindGroup(bind_group));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
diff --git a/op_crates/webgpu/buffer.rs b/op_crates/webgpu/buffer.rs
index ade4122d5..19fc428cb 100644
--- a/op_crates/webgpu/buffer.rs
+++ b/op_crates/webgpu/buffer.rs
@@ -4,8 +4,6 @@ use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf;
use deno_core::error::AnyError;
use deno_core::futures::channel::oneshot;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::OpState;
use deno_core::Resource;
use deno_core::ResourceId;
@@ -17,7 +15,7 @@ use std::rc::Rc;
use std::time::Duration;
use super::error::DomExceptionOperationError;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
pub(crate) struct WebGpuBuffer(pub(crate) wgpu_core::id::BufferId);
impl Resource for WebGpuBuffer {
@@ -47,7 +45,7 @@ pub fn op_webgpu_create_buffer(
state: &mut OpState,
args: CreateBufferArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -70,10 +68,7 @@ pub fn op_webgpu_create_buffer(
let rid = state.resource_table.add(WebGpuBuffer(buffer));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -90,7 +85,7 @@ pub async fn op_webgpu_buffer_get_map_async(
state: Rc<RefCell<OpState>>,
args: BufferGetMapAsyncArgs,
_bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let (sender, receiver) = oneshot::channel::<Result<(), AnyError>>();
let device;
@@ -164,7 +159,7 @@ pub async fn op_webgpu_buffer_get_map_async(
tokio::try_join!(device_poll_fut, receiver_fut)?;
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -179,7 +174,7 @@ pub fn op_webgpu_buffer_get_mapped_range(
state: &mut OpState,
args: BufferGetMappedRangeArgs,
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let mut zero_copy = zero_copy.ok_or_else(null_opbuf)?;
let instance = state.borrow::<super::Instance>();
let buffer_resource = state
@@ -204,9 +199,7 @@ pub fn op_webgpu_buffer_get_mapped_range(
.resource_table
.add(WebGpuBufferMapped(slice_pointer, args.size as usize));
- Ok(json!({
- "rid": rid,
- }))
+ Ok(WebGpuResult::rid(rid))
}
#[derive(Deserialize)]
@@ -220,7 +213,7 @@ pub fn op_webgpu_buffer_unmap(
state: &mut OpState,
args: BufferUnmapArgs,
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let mapped_resource = state
.resource_table
.take::<WebGpuBufferMapped>(args.mapped_rid)
@@ -242,5 +235,5 @@ pub fn op_webgpu_buffer_unmap(
let maybe_err = gfx_select!(buffer => instance.buffer_unmap(buffer)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
diff --git a/op_crates/webgpu/bundle.rs b/op_crates/webgpu/bundle.rs
index 58915b108..72abb18e6 100644
--- a/op_crates/webgpu/bundle.rs
+++ b/op_crates/webgpu/bundle.rs
@@ -3,8 +3,6 @@
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
@@ -13,7 +11,7 @@ use std::borrow::Cow;
use std::cell::RefCell;
use std::rc::Rc;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
use super::texture::serialize_texture_format;
struct WebGpuRenderBundleEncoder(
@@ -46,7 +44,7 @@ pub fn op_webgpu_create_render_bundle_encoder(
state: &mut OpState,
args: CreateRenderBundleEncoderArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let device_resource = state
.resource_table
.get::<super::WebGpuDevice>(args.device_rid)
@@ -85,10 +83,7 @@ pub fn op_webgpu_create_render_bundle_encoder(
render_bundle_encoder,
)));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from),
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -102,7 +97,7 @@ pub fn op_webgpu_render_bundle_encoder_finish(
state: &mut OpState,
args: RenderBundleEncoderFinishArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state
.resource_table
.take::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -124,10 +119,7 @@ pub fn op_webgpu_render_bundle_encoder_finish(
let rid = state.resource_table.add(WebGpuRenderBundle(render_bundle));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -145,7 +137,7 @@ pub fn op_webgpu_render_bundle_encoder_set_bind_group(
state: &mut OpState,
args: RenderBundleEncoderSetBindGroupArgs,
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let zero_copy = zero_copy.ok_or_else(null_opbuf)?;
let bind_group_resource = state
@@ -188,7 +180,7 @@ pub fn op_webgpu_render_bundle_encoder_set_bind_group(
}
};
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -202,7 +194,7 @@ pub fn op_webgpu_render_bundle_encoder_push_debug_group(
state: &mut OpState,
args: RenderBundleEncoderPushDebugGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state
.resource_table
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -216,7 +208,7 @@ pub fn op_webgpu_render_bundle_encoder_push_debug_group(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -229,7 +221,7 @@ pub fn op_webgpu_render_bundle_encoder_pop_debug_group(
state: &mut OpState,
args: RenderBundleEncoderPopDebugGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state
.resource_table
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -241,7 +233,7 @@ pub fn op_webgpu_render_bundle_encoder_pop_debug_group(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -255,7 +247,7 @@ pub fn op_webgpu_render_bundle_encoder_insert_debug_marker(
state: &mut OpState,
args: RenderBundleEncoderInsertDebugMarkerArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state
.resource_table
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -269,7 +261,7 @@ pub fn op_webgpu_render_bundle_encoder_insert_debug_marker(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -283,7 +275,7 @@ pub fn op_webgpu_render_bundle_encoder_set_pipeline(
state: &mut OpState,
args: RenderBundleEncoderSetPipelineArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pipeline_resource = state
.resource_table
.get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)
@@ -298,7 +290,7 @@ pub fn op_webgpu_render_bundle_encoder_set_pipeline(
render_pipeline_resource.0,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -315,7 +307,7 @@ pub fn op_webgpu_render_bundle_encoder_set_index_buffer(
state: &mut OpState,
args: RenderBundleEncoderSetIndexBufferArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state
.resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer)
@@ -335,7 +327,7 @@ pub fn op_webgpu_render_bundle_encoder_set_index_buffer(
std::num::NonZeroU64::new(args.size),
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -352,7 +344,7 @@ pub fn op_webgpu_render_bundle_encoder_set_vertex_buffer(
state: &mut OpState,
args: RenderBundleEncoderSetVertexBufferArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state
.resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer)
@@ -370,7 +362,7 @@ pub fn op_webgpu_render_bundle_encoder_set_vertex_buffer(
std::num::NonZeroU64::new(args.size),
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -387,7 +379,7 @@ pub fn op_webgpu_render_bundle_encoder_draw(
state: &mut OpState,
args: RenderBundleEncoderDrawArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state
.resource_table
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -401,7 +393,7 @@ pub fn op_webgpu_render_bundle_encoder_draw(
args.first_instance,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -419,7 +411,7 @@ pub fn op_webgpu_render_bundle_encoder_draw_indexed(
state: &mut OpState,
args: RenderBundleEncoderDrawIndexedArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_bundle_encoder_resource = state
.resource_table
.get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -434,7 +426,7 @@ pub fn op_webgpu_render_bundle_encoder_draw_indexed(
args.first_instance,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -449,7 +441,7 @@ pub fn op_webgpu_render_bundle_encoder_draw_indirect(
state: &mut OpState,
args: RenderBundleEncoderDrawIndirectArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state
.resource_table
.get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
@@ -465,5 +457,5 @@ pub fn op_webgpu_render_bundle_encoder_draw_indirect(
args.indirect_offset,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
diff --git a/op_crates/webgpu/command_encoder.rs b/op_crates/webgpu/command_encoder.rs
index 801682f56..724ce72c4 100644
--- a/op_crates/webgpu/command_encoder.rs
+++ b/op_crates/webgpu/command_encoder.rs
@@ -2,8 +2,6 @@
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
@@ -11,7 +9,7 @@ use serde::Deserialize;
use std::borrow::Cow;
use std::cell::RefCell;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
pub(crate) struct WebGpuCommandEncoder(
pub(crate) wgpu_core::id::CommandEncoderId,
@@ -51,7 +49,7 @@ pub fn op_webgpu_create_command_encoder(
state: &mut OpState,
args: CreateCommandEncoderArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -73,10 +71,7 @@ pub fn op_webgpu_create_command_encoder(
.resource_table
.add(WebGpuCommandEncoder(command_encoder));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from),
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -117,7 +112,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
state: &mut OpState,
args: CommandEncoderBeginRenderPassArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let command_encoder_resource = state
.resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid)
@@ -236,9 +231,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
render_pass,
)));
- Ok(json!({
- "rid": rid,
- }))
+ Ok(WebGpuResult::rid(rid))
}
#[derive(Deserialize)]
@@ -252,7 +245,7 @@ pub fn op_webgpu_command_encoder_begin_compute_pass(
state: &mut OpState,
args: CommandEncoderBeginComputePassArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let command_encoder_resource = state
.resource_table
.get::<WebGpuCommandEncoder>(args.command_encoder_rid)
@@ -273,9 +266,7 @@ pub fn op_webgpu_command_encoder_begin_compute_pass(
compute_pass,
)));
- Ok(json!({
- "rid": rid,
- }))
+ Ok(WebGpuResult::rid(rid))
}
#[derive(Deserialize)]
@@ -293,7 +284,7 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
state: &mut OpState,
args: CommandEncoderCopyBufferToBufferArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -320,7 +311,7 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
args.size
)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -362,7 +353,7 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
state: &mut OpState,
args: CommandEncoderCopyBufferToTextureArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -409,7 +400,7 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
}
)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -425,7 +416,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
state: &mut OpState,
args: CommandEncoderCopyTextureToBufferArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -471,7 +462,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
}
)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -487,7 +478,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_texture(
state: &mut OpState,
args: CommandEncoderCopyTextureToTextureArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -537,7 +528,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_texture(
}
)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -551,7 +542,7 @@ pub fn op_webgpu_command_encoder_push_debug_group(
state: &mut OpState,
args: CommandEncoderPushDebugGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -563,7 +554,7 @@ pub fn op_webgpu_command_encoder_push_debug_group(
.command_encoder_push_debug_group(command_encoder, &args.group_label))
.err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -576,7 +567,7 @@ pub fn op_webgpu_command_encoder_pop_debug_group(
state: &mut OpState,
args: CommandEncoderPopDebugGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -586,7 +577,7 @@ pub fn op_webgpu_command_encoder_pop_debug_group(
let maybe_err = gfx_select!(command_encoder => instance.command_encoder_pop_debug_group(command_encoder)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -600,7 +591,7 @@ pub fn op_webgpu_command_encoder_insert_debug_marker(
state: &mut OpState,
args: CommandEncoderInsertDebugMarkerArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -613,7 +604,7 @@ pub fn op_webgpu_command_encoder_insert_debug_marker(
&args.marker_label
)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -628,7 +619,7 @@ pub fn op_webgpu_command_encoder_write_timestamp(
state: &mut OpState,
args: CommandEncoderWriteTimestampArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -648,7 +639,7 @@ pub fn op_webgpu_command_encoder_write_timestamp(
))
.err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -666,7 +657,7 @@ pub fn op_webgpu_command_encoder_resolve_query_set(
state: &mut OpState,
args: CommandEncoderResolveQuerySetArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let command_encoder_resource = state
.resource_table
@@ -693,7 +684,7 @@ pub fn op_webgpu_command_encoder_resolve_query_set(
))
.err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -707,7 +698,7 @@ pub fn op_webgpu_command_encoder_finish(
state: &mut OpState,
args: CommandEncoderFinishArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let command_encoder_resource = state
.resource_table
.take::<WebGpuCommandEncoder>(args.command_encoder_rid)
@@ -728,8 +719,5 @@ pub fn op_webgpu_command_encoder_finish(
.resource_table
.add(WebGpuCommandBuffer(command_buffer));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
diff --git a/op_crates/webgpu/compute_pass.rs b/op_crates/webgpu/compute_pass.rs
index 2e1fb1ac1..e8ec642e9 100644
--- a/op_crates/webgpu/compute_pass.rs
+++ b/op_crates/webgpu/compute_pass.rs
@@ -3,8 +3,6 @@
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
@@ -12,7 +10,7 @@ use serde::Deserialize;
use std::borrow::Cow;
use std::cell::RefCell;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
pub(crate) struct WebGpuComputePass(
pub(crate) RefCell<wgpu_core::command::ComputePass>,
@@ -34,7 +32,7 @@ pub fn op_webgpu_compute_pass_set_pipeline(
state: &mut OpState,
args: ComputePassSetPipelineArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let compute_pipeline_resource = state
.resource_table
.get::<super::pipeline::WebGpuComputePipeline>(args.pipeline)
@@ -49,7 +47,7 @@ pub fn op_webgpu_compute_pass_set_pipeline(
compute_pipeline_resource.0,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -65,7 +63,7 @@ pub fn op_webgpu_compute_pass_dispatch(
state: &mut OpState,
args: ComputePassDispatchArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state
.resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -78,7 +76,7 @@ pub fn op_webgpu_compute_pass_dispatch(
args.z,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -93,7 +91,7 @@ pub fn op_webgpu_compute_pass_dispatch_indirect(
state: &mut OpState,
args: ComputePassDispatchIndirectArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state
.resource_table
.get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
@@ -109,7 +107,7 @@ pub fn op_webgpu_compute_pass_dispatch_indirect(
args.indirect_offset,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -124,7 +122,7 @@ pub fn op_webgpu_compute_pass_begin_pipeline_statistics_query(
state: &mut OpState,
args: ComputePassBeginPipelineStatisticsQueryArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state
.resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -142,7 +140,7 @@ pub fn op_webgpu_compute_pass_begin_pipeline_statistics_query(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -155,7 +153,7 @@ pub fn op_webgpu_compute_pass_end_pipeline_statistics_query(
state: &mut OpState,
args: ComputePassEndPipelineStatisticsQueryArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state
.resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -167,7 +165,7 @@ pub fn op_webgpu_compute_pass_end_pipeline_statistics_query(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -182,7 +180,7 @@ pub fn op_webgpu_compute_pass_write_timestamp(
state: &mut OpState,
args: ComputePassWriteTimestampArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state
.resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -200,7 +198,7 @@ pub fn op_webgpu_compute_pass_write_timestamp(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -214,7 +212,7 @@ pub fn op_webgpu_compute_pass_end_pass(
state: &mut OpState,
args: ComputePassEndPassArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let command_encoder_resource = state
.resource_table
.get::<super::command_encoder::WebGpuCommandEncoder>(
@@ -236,7 +234,7 @@ pub fn op_webgpu_compute_pass_end_pass(
))
.err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -254,7 +252,7 @@ pub fn op_webgpu_compute_pass_set_bind_group(
state: &mut OpState,
args: ComputePassSetBindGroupArgs,
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let bind_group_resource = state
.resource_table
.get::<super::binding::WebGpuBindGroup>(args.bind_group)
@@ -283,7 +281,7 @@ pub fn op_webgpu_compute_pass_set_bind_group(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -297,7 +295,7 @@ pub fn op_webgpu_compute_pass_push_debug_group(
state: &mut OpState,
args: ComputePassPushDebugGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state
.resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -312,7 +310,7 @@ pub fn op_webgpu_compute_pass_push_debug_group(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -325,7 +323,7 @@ pub fn op_webgpu_compute_pass_pop_debug_group(
state: &mut OpState,
args: ComputePassPopDebugGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state
.resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -335,7 +333,7 @@ pub fn op_webgpu_compute_pass_pop_debug_group(
&mut compute_pass_resource.0.borrow_mut(),
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -349,7 +347,7 @@ pub fn op_webgpu_compute_pass_insert_debug_marker(
state: &mut OpState,
args: ComputePassInsertDebugMarkerArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let compute_pass_resource = state
.resource_table
.get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -364,5 +362,5 @@ pub fn op_webgpu_compute_pass_insert_debug_marker(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
diff --git a/op_crates/webgpu/error.rs b/op_crates/webgpu/error.rs
index 15036512e..57e2e675f 100644
--- a/op_crates/webgpu/error.rs
+++ b/op_crates/webgpu/error.rs
@@ -1,6 +1,8 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use deno_core::error::AnyError;
+use deno_core::ResourceId;
use serde::Serialize;
+use std::convert::From;
use std::fmt;
use wgpu_core::binding_model::CreateBindGroupError;
use wgpu_core::binding_model::CreateBindGroupLayoutError;
@@ -28,6 +30,45 @@ use wgpu_core::resource::CreateTextureError;
use wgpu_core::resource::CreateTextureViewError;
#[derive(Serialize)]
+pub struct WebGpuResult {
+ pub rid: Option<ResourceId>,
+ pub err: Option<WebGpuError>,
+}
+
+impl WebGpuResult {
+ pub fn rid(rid: ResourceId) -> Self {
+ Self {
+ rid: Some(rid),
+ err: None,
+ }
+ }
+
+ pub fn rid_err<T: Into<WebGpuError>>(
+ rid: ResourceId,
+ err: Option<T>,
+ ) -> Self {
+ Self {
+ rid: Some(rid),
+ err: err.map(|e| e.into()),
+ }
+ }
+
+ pub fn maybe_err<T: Into<WebGpuError>>(err: Option<T>) -> Self {
+ Self {
+ rid: None,
+ err: err.map(|e| e.into()),
+ }
+ }
+
+ pub fn empty() -> Self {
+ Self {
+ rid: None,
+ err: None,
+ }
+ }
+}
+
+#[derive(Serialize)]
#[serde(tag = "type", content = "value")]
#[serde(rename_all = "kebab-case")]
pub enum WebGpuError {
diff --git a/op_crates/webgpu/lib.rs b/op_crates/webgpu/lib.rs
index b1c8a631d..0dd18ca8e 100644
--- a/op_crates/webgpu/lib.rs
+++ b/op_crates/webgpu/lib.rs
@@ -4,13 +4,12 @@
use deno_core::error::AnyError;
use deno_core::error::{bad_resource_id, not_supported};
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::OpState;
use deno_core::Resource;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use serde::Deserialize;
+use serde::Serialize;
use std::borrow::Cow;
use std::cell::RefCell;
use std::path::PathBuf;
@@ -19,7 +18,7 @@ pub use wgpu_core;
pub use wgpu_types;
use error::DomExceptionOperationError;
-use error::WebGpuError;
+use error::WebGpuResult;
#[macro_use]
mod macros {
@@ -113,8 +112,8 @@ pub fn get_declaration() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_webgpu.d.ts")
}
-fn deserialize_features(features: &wgpu_types::Features) -> Vec<&str> {
- let mut return_features: Vec<&str> = vec![];
+fn deserialize_features(features: &wgpu_types::Features) -> Vec<&'static str> {
+ let mut return_features: Vec<&'static str> = vec![];
if features.contains(wgpu_types::Features::DEPTH_CLAMPING) {
return_features.push("depth-clamping");
@@ -191,11 +190,27 @@ pub struct RequestAdapterArgs {
power_preference: Option<String>,
}
+#[derive(Serialize)]
+#[serde(untagged)]
+pub enum GpuAdapterDeviceOrErr {
+ Error { err: String },
+ Features(GpuAdapterDevice),
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GpuAdapterDevice {
+ rid: ResourceId,
+ name: Option<String>,
+ limits: wgpu_types::Limits,
+ features: Vec<&'static str>,
+}
+
pub async fn op_webgpu_request_adapter(
state: Rc<RefCell<OpState>>,
args: RequestAdapterArgs,
_bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<GpuAdapterDeviceOrErr, AnyError> {
let mut state = state.borrow_mut();
check_unstable(&state, "navigator.gpu.requestAdapter");
let instance = if let Some(instance) = state.try_borrow::<Instance>() {
@@ -231,9 +246,9 @@ pub async fn op_webgpu_request_adapter(
let adapter = match res {
Ok(adapter) => adapter,
Err(err) => {
- return Ok(json!({
- "err": err.to_string()
- }))
+ return Ok(GpuAdapterDeviceOrErr::Error {
+ err: err.to_string(),
+ })
}
};
let name = gfx_select!(adapter => instance.adapter_get_info(adapter))?.name;
@@ -243,25 +258,13 @@ pub async fn op_webgpu_request_adapter(
let adapter_limits =
gfx_select!(adapter => instance.adapter_limits(adapter))?;
- let limits = json!({
- "maxBindGroups": adapter_limits.max_bind_groups,
- "maxDynamicUniformBuffersPerPipelineLayout": adapter_limits.max_dynamic_uniform_buffers_per_pipeline_layout,
- "maxDynamicStorageBuffersPerPipelineLayout": adapter_limits.max_dynamic_storage_buffers_per_pipeline_layout,
- "maxSampledTexturesPerShaderStage": adapter_limits.max_sampled_textures_per_shader_stage,
- "maxSamplersPerShaderStage": adapter_limits.max_samplers_per_shader_stage,
- "maxStorageBuffersPerShaderStage": adapter_limits.max_storage_buffers_per_shader_stage,
- "maxStorageTexturesPerShaderStage": adapter_limits.max_storage_textures_per_shader_stage,
- "maxUniformBuffersPerShaderStage": adapter_limits.max_uniform_buffers_per_shader_stage,
- "maxUniformBufferBindingSize": adapter_limits.max_uniform_buffer_binding_size
- });
-
let rid = state.resource_table.add(WebGpuAdapter(adapter));
- Ok(json!({
- "rid": rid,
- "name": name,
- "features": features,
- "limits": limits
+ Ok(GpuAdapterDeviceOrErr::Features(GpuAdapterDevice {
+ rid,
+ name: Some(name),
+ features,
+ limits: adapter_limits,
}))
}
@@ -300,7 +303,7 @@ pub async fn op_webgpu_request_device(
state: Rc<RefCell<OpState>>,
args: RequestDeviceArgs,
_bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<GpuAdapterDevice, AnyError> {
let mut state = state.borrow_mut();
let adapter_resource = state
.resource_table
@@ -437,25 +440,15 @@ pub async fn op_webgpu_request_device(
gfx_select!(device => instance.device_features(device))?;
let features = deserialize_features(&device_features);
let limits = gfx_select!(device => instance.device_limits(device))?;
- let json_limits = json!({
- "maxBindGroups": limits.max_bind_groups,
- "maxDynamicUniformBuffersPerPipelineLayout": limits.max_dynamic_uniform_buffers_per_pipeline_layout,
- "maxDynamicStorageBuffersPerPipelineLayout": limits.max_dynamic_storage_buffers_per_pipeline_layout,
- "maxSampledTexturesPerShaderStage": limits.max_sampled_textures_per_shader_stage,
- "maxSamplersPerShaderStage": limits.max_samplers_per_shader_stage,
- "maxStorageBuffersPerShaderStage": limits.max_storage_buffers_per_shader_stage,
- "maxStorageTexturesPerShaderStage": limits.max_storage_textures_per_shader_stage,
- "maxUniformBuffersPerShaderStage": limits.max_uniform_buffers_per_shader_stage,
- "maxUniformBufferBindingSize": limits.max_uniform_buffer_binding_size,
- });
let rid = state.resource_table.add(WebGpuDevice(device));
- Ok(json!({
- "rid": rid,
- "features": features,
- "limits": json_limits,
- }))
+ Ok(GpuAdapterDevice {
+ rid,
+ name: None,
+ features,
+ limits,
+ })
}
#[derive(Deserialize)]
@@ -473,7 +466,7 @@ pub fn op_webgpu_create_query_set(
state: &mut OpState,
args: CreateQuerySetArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let device_resource = state
.resource_table
.get::<WebGpuDevice>(args.device_rid)
@@ -544,8 +537,5 @@ pub fn op_webgpu_create_query_set(
let rid = state.resource_table.add(WebGpuQuerySet(query_set));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from),
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
diff --git a/op_crates/webgpu/pipeline.rs b/op_crates/webgpu/pipeline.rs
index 10e300a57..8eb291b97 100644
--- a/op_crates/webgpu/pipeline.rs
+++ b/op_crates/webgpu/pipeline.rs
@@ -2,15 +2,14 @@
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
use serde::Deserialize;
+use serde::Serialize;
use std::borrow::Cow;
-use super::error::WebGpuError;
+use super::error::{WebGpuError, WebGpuResult};
pub(crate) struct WebGpuPipelineLayout(
pub(crate) wgpu_core::id::PipelineLayoutId,
@@ -163,7 +162,7 @@ pub fn op_webgpu_create_compute_pipeline(
state: &mut OpState,
args: CreateComputePipelineArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -213,10 +212,7 @@ pub fn op_webgpu_create_compute_pipeline(
.resource_table
.add(WebGpuComputePipeline(compute_pipeline));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from),
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -226,11 +222,19 @@ pub struct ComputePipelineGetBindGroupLayoutArgs {
index: u32,
}
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PipelineLayout {
+ rid: ResourceId,
+ label: String,
+ err: Option<WebGpuError>,
+}
+
pub fn op_webgpu_compute_pipeline_get_bind_group_layout(
state: &mut OpState,
args: ComputePipelineGetBindGroupLayoutArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<PipelineLayout, AnyError> {
let instance = state.borrow::<super::Instance>();
let compute_pipeline_resource = state
.resource_table
@@ -246,11 +250,11 @@ pub fn op_webgpu_compute_pipeline_get_bind_group_layout(
.resource_table
.add(super::binding::WebGpuBindGroupLayout(bind_group_layout));
- Ok(json!({
- "rid": rid,
- "label": label,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(PipelineLayout {
+ rid,
+ label,
+ err: maybe_err.map(WebGpuError::from),
+ })
}
#[derive(Deserialize)]
@@ -367,7 +371,7 @@ pub fn op_webgpu_create_render_pipeline(
state: &mut OpState,
args: CreateRenderPipelineArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -601,10 +605,7 @@ pub fn op_webgpu_create_render_pipeline(
.resource_table
.add(WebGpuRenderPipeline(render_pipeline));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -618,7 +619,7 @@ pub fn op_webgpu_render_pipeline_get_bind_group_layout(
state: &mut OpState,
args: RenderPipelineGetBindGroupLayoutArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<PipelineLayout, AnyError> {
let instance = state.borrow::<super::Instance>();
let render_pipeline_resource = state
.resource_table
@@ -634,9 +635,9 @@ pub fn op_webgpu_render_pipeline_get_bind_group_layout(
.resource_table
.add(super::binding::WebGpuBindGroupLayout(bind_group_layout));
- Ok(json!({
- "rid": rid,
- "label": label,
- "err": maybe_err.map(WebGpuError::from),
- }))
+ Ok(PipelineLayout {
+ rid,
+ label,
+ err: maybe_err.map(WebGpuError::from),
+ })
}
diff --git a/op_crates/webgpu/queue.rs b/op_crates/webgpu/queue.rs
index c96e2a158..93fd95502 100644
--- a/op_crates/webgpu/queue.rs
+++ b/op_crates/webgpu/queue.rs
@@ -3,14 +3,12 @@
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::OpState;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use serde::Deserialize;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
type WebGpuQueue = super::WebGpuDevice;
@@ -25,7 +23,7 @@ pub fn op_webgpu_queue_submit(
state: &mut OpState,
args: QueueSubmitArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let queue_resource = state
.resource_table
@@ -46,7 +44,7 @@ pub fn op_webgpu_queue_submit(
let maybe_err =
gfx_select!(queue => instance.queue_submit(queue, &ids)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -71,7 +69,7 @@ pub fn op_webgpu_write_buffer(
state: &mut OpState,
args: QueueWriteBufferArgs,
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let zero_copy = zero_copy.ok_or_else(null_opbuf)?;
let instance = state.borrow::<super::Instance>();
let buffer_resource = state
@@ -97,7 +95,7 @@ pub fn op_webgpu_write_buffer(
))
.err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -113,7 +111,7 @@ pub fn op_webgpu_write_texture(
state: &mut OpState,
args: QueueWriteTextureArgs,
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let zero_copy = zero_copy.ok_or_else(null_opbuf)?;
let instance = state.borrow::<super::Instance>();
let texture_resource = state
@@ -157,5 +155,5 @@ pub fn op_webgpu_write_texture(
))
.err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
diff --git a/op_crates/webgpu/render_pass.rs b/op_crates/webgpu/render_pass.rs
index bf3bd092d..38ebd6db8 100644
--- a/op_crates/webgpu/render_pass.rs
+++ b/op_crates/webgpu/render_pass.rs
@@ -3,8 +3,6 @@
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
@@ -12,7 +10,7 @@ use serde::Deserialize;
use std::borrow::Cow;
use std::cell::RefCell;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
pub(crate) struct WebGpuRenderPass(
pub(crate) RefCell<wgpu_core::command::RenderPass>,
@@ -39,7 +37,7 @@ pub fn op_webgpu_render_pass_set_viewport(
state: &mut OpState,
args: RenderPassSetViewportArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -55,7 +53,7 @@ pub fn op_webgpu_render_pass_set_viewport(
args.max_depth,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -72,7 +70,7 @@ pub fn op_webgpu_render_pass_set_scissor_rect(
state: &mut OpState,
args: RenderPassSetScissorRectArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -86,7 +84,7 @@ pub fn op_webgpu_render_pass_set_scissor_rect(
args.height,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -109,7 +107,7 @@ pub fn op_webgpu_render_pass_set_blend_color(
state: &mut OpState,
args: RenderPassSetBlendColorArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -125,7 +123,7 @@ pub fn op_webgpu_render_pass_set_blend_color(
},
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -139,7 +137,7 @@ pub fn op_webgpu_render_pass_set_stencil_reference(
state: &mut OpState,
args: RenderPassSetStencilReferenceArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -150,7 +148,7 @@ pub fn op_webgpu_render_pass_set_stencil_reference(
args.reference,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -165,7 +163,7 @@ pub fn op_webgpu_render_pass_begin_pipeline_statistics_query(
state: &mut OpState,
args: RenderPassBeginPipelineStatisticsQueryArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -183,7 +181,7 @@ pub fn op_webgpu_render_pass_begin_pipeline_statistics_query(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -196,7 +194,7 @@ pub fn op_webgpu_render_pass_end_pipeline_statistics_query(
state: &mut OpState,
args: RenderPassEndPipelineStatisticsQueryArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -208,7 +206,7 @@ pub fn op_webgpu_render_pass_end_pipeline_statistics_query(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -223,7 +221,7 @@ pub fn op_webgpu_render_pass_write_timestamp(
state: &mut OpState,
args: RenderPassWriteTimestampArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -241,7 +239,7 @@ pub fn op_webgpu_render_pass_write_timestamp(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -255,7 +253,7 @@ pub fn op_webgpu_render_pass_execute_bundles(
state: &mut OpState,
args: RenderPassExecuteBundlesArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let mut render_bundle_ids = vec![];
for rid in &args.bundles {
@@ -279,7 +277,7 @@ pub fn op_webgpu_render_pass_execute_bundles(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -293,7 +291,7 @@ pub fn op_webgpu_render_pass_end_pass(
state: &mut OpState,
args: RenderPassEndPassArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let command_encoder_resource = state
.resource_table
.get::<super::command_encoder::WebGpuCommandEncoder>(
@@ -310,7 +308,7 @@ pub fn op_webgpu_render_pass_end_pass(
let maybe_err = gfx_select!(command_encoder => instance.command_encoder_run_render_pass(command_encoder, render_pass)).err();
- Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+ Ok(WebGpuResult::maybe_err(maybe_err))
}
#[derive(Deserialize)]
@@ -328,7 +326,7 @@ pub fn op_webgpu_render_pass_set_bind_group(
state: &mut OpState,
args: RenderPassSetBindGroupArgs,
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let zero_copy = zero_copy.ok_or_else(null_opbuf)?;
let bind_group_resource = state
.resource_table
@@ -370,7 +368,7 @@ pub fn op_webgpu_render_pass_set_bind_group(
}
};
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -384,7 +382,7 @@ pub fn op_webgpu_render_pass_push_debug_group(
state: &mut OpState,
args: RenderPassPushDebugGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -399,7 +397,7 @@ pub fn op_webgpu_render_pass_push_debug_group(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -412,7 +410,7 @@ pub fn op_webgpu_render_pass_pop_debug_group(
state: &mut OpState,
args: RenderPassPopDebugGroupArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -422,7 +420,7 @@ pub fn op_webgpu_render_pass_pop_debug_group(
&mut render_pass_resource.0.borrow_mut(),
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -436,7 +434,7 @@ pub fn op_webgpu_render_pass_insert_debug_marker(
state: &mut OpState,
args: RenderPassInsertDebugMarkerArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -451,7 +449,7 @@ pub fn op_webgpu_render_pass_insert_debug_marker(
);
}
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -465,7 +463,7 @@ pub fn op_webgpu_render_pass_set_pipeline(
state: &mut OpState,
args: RenderPassSetPipelineArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pipeline_resource = state
.resource_table
.get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)
@@ -480,7 +478,7 @@ pub fn op_webgpu_render_pass_set_pipeline(
render_pipeline_resource.0,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -497,7 +495,7 @@ pub fn op_webgpu_render_pass_set_index_buffer(
state: &mut OpState,
args: RenderPassSetIndexBufferArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state
.resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer)
@@ -514,7 +512,7 @@ pub fn op_webgpu_render_pass_set_index_buffer(
std::num::NonZeroU64::new(args.size),
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -531,7 +529,7 @@ pub fn op_webgpu_render_pass_set_vertex_buffer(
state: &mut OpState,
args: RenderPassSetVertexBufferArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state
.resource_table
.get::<super::buffer::WebGpuBuffer>(args.buffer)
@@ -549,7 +547,7 @@ pub fn op_webgpu_render_pass_set_vertex_buffer(
std::num::NonZeroU64::new(args.size),
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -566,7 +564,7 @@ pub fn op_webgpu_render_pass_draw(
state: &mut OpState,
args: RenderPassDrawArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -580,7 +578,7 @@ pub fn op_webgpu_render_pass_draw(
args.first_instance,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -598,7 +596,7 @@ pub fn op_webgpu_render_pass_draw_indexed(
state: &mut OpState,
args: RenderPassDrawIndexedArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let render_pass_resource = state
.resource_table
.get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -613,7 +611,7 @@ pub fn op_webgpu_render_pass_draw_indexed(
args.first_instance,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -628,7 +626,7 @@ pub fn op_webgpu_render_pass_draw_indirect(
state: &mut OpState,
args: RenderPassDrawIndirectArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state
.resource_table
.get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
@@ -644,7 +642,7 @@ pub fn op_webgpu_render_pass_draw_indirect(
args.indirect_offset,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
#[derive(Deserialize)]
@@ -659,7 +657,7 @@ pub fn op_webgpu_render_pass_draw_indexed_indirect(
state: &mut OpState,
args: RenderPassDrawIndexedIndirectArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let buffer_resource = state
.resource_table
.get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
@@ -675,5 +673,5 @@ pub fn op_webgpu_render_pass_draw_indexed_indirect(
args.indirect_offset,
);
- Ok(json!({}))
+ Ok(WebGpuResult::empty())
}
diff --git a/op_crates/webgpu/sampler.rs b/op_crates/webgpu/sampler.rs
index b759d0c11..5e0ebc61e 100644
--- a/op_crates/webgpu/sampler.rs
+++ b/op_crates/webgpu/sampler.rs
@@ -2,15 +2,13 @@
use deno_core::error::bad_resource_id;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
use serde::Deserialize;
use std::borrow::Cow;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
pub(crate) struct WebGpuSampler(pub(crate) wgpu_core::id::SamplerId);
impl Resource for WebGpuSampler {
@@ -83,7 +81,7 @@ pub fn op_webgpu_create_sampler(
state: &mut OpState,
args: CreateSamplerArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -123,8 +121,5 @@ pub fn op_webgpu_create_sampler(
let rid = state.resource_table.add(WebGpuSampler(sampler));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
diff --git a/op_crates/webgpu/shader.rs b/op_crates/webgpu/shader.rs
index 63578ce64..0e653b470 100644
--- a/op_crates/webgpu/shader.rs
+++ b/op_crates/webgpu/shader.rs
@@ -3,15 +3,13 @@
use deno_core::error::bad_resource_id;
use deno_core::error::null_opbuf;
use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
use serde::Deserialize;
use std::borrow::Cow;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
pub(crate) struct WebGpuShaderModule(pub(crate) wgpu_core::id::ShaderModuleId);
impl Resource for WebGpuShaderModule {
@@ -33,7 +31,7 @@ pub fn op_webgpu_create_shader_module(
state: &mut OpState,
args: CreateShaderModuleArgs,
zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -77,8 +75,5 @@ pub fn op_webgpu_create_shader_module(
let rid = state.resource_table.add(WebGpuShaderModule(shader_module));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
diff --git a/op_crates/webgpu/texture.rs b/op_crates/webgpu/texture.rs
index 24824215c..28b8ca1a4 100644
--- a/op_crates/webgpu/texture.rs
+++ b/op_crates/webgpu/texture.rs
@@ -2,15 +2,13 @@
use deno_core::error::AnyError;
use deno_core::error::{bad_resource_id, not_supported};
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
use deno_core::{OpState, Resource};
use serde::Deserialize;
use std::borrow::Cow;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
pub(crate) struct WebGpuTexture(pub(crate) wgpu_core::id::TextureId);
impl Resource for WebGpuTexture {
fn name(&self) -> Cow<str> {
@@ -148,7 +146,7 @@ pub fn op_webgpu_create_texture(
state: &mut OpState,
args: CreateTextureArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let device_resource = state
.resource_table
@@ -186,10 +184,7 @@ pub fn op_webgpu_create_texture(
let rid = state.resource_table.add(WebGpuTexture(texture));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
#[derive(Deserialize)]
@@ -210,7 +205,7 @@ pub fn op_webgpu_create_texture_view(
state: &mut OpState,
args: CreateTextureViewArgs,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
let instance = state.borrow::<super::Instance>();
let texture_resource = state
.resource_table
@@ -250,8 +245,5 @@ pub fn op_webgpu_create_texture_view(
let rid = state.resource_table.add(WebGpuTextureView(texture_view));
- Ok(json!({
- "rid": rid,
- "err": maybe_err.map(WebGpuError::from)
- }))
+ Ok(WebGpuResult::rid_err(rid, maybe_err))
}
diff --git a/op_crates/websocket/01_websocket.js b/op_crates/websocket/01_websocket.js
index 67fc0e481..60fd7d467 100644
--- a/op_crates/websocket/01_websocket.js
+++ b/op_crates/websocket/01_websocket.js
@@ -99,9 +99,7 @@
this.#url = wsURL.href;
- core.jsonOpSync("op_ws_check_permission", {
- url: this.#url,
- });
+ core.jsonOpSync("op_ws_check_permission", this.#url);
if (protocols && typeof protocols === "string") {
protocols = [protocols];
@@ -311,7 +309,7 @@
while (this.#readyState === OPEN) {
const message = await core.jsonOpAsync(
"op_ws_next_event",
- { rid: this.#rid },
+ this.#rid,
);
switch (message.kind) {
diff --git a/op_crates/websocket/lib.rs b/op_crates/websocket/lib.rs
index 79ddbbee2..1e6eaafb7 100644
--- a/op_crates/websocket/lib.rs
+++ b/op_crates/websocket/lib.rs
@@ -82,28 +82,22 @@ impl Resource for WsStreamResource {
impl WsStreamResource {}
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CheckPermissionArgs {
- url: String,
-}
-
// This op is needed because creating a WS instance in JavaScript is a sync
// operation and should throw error when permissions are not fulfilled,
// but actual op that connects WS is async.
pub fn op_ws_check_permission<WP>(
state: &mut OpState,
- args: CheckPermissionArgs,
+ url: String,
_zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError>
+) -> Result<(), AnyError>
where
WP: WebSocketPermissions + 'static,
{
state
.borrow::<WP>()
- .check_net_url(&url::Url::parse(&args.url)?)?;
+ .check_net_url(&url::Url::parse(&url)?)?;
- Ok(json!({}))
+ Ok(())
}
#[derive(Deserialize)]
@@ -224,7 +218,7 @@ pub async fn op_ws_send(
state: Rc<RefCell<OpState>>,
args: SendArgs,
buf: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<(), AnyError> {
let msg = match args.kind.as_str() {
"text" => Message::Text(args.text.unwrap()),
"binary" => Message::Binary(buf.ok_or_else(null_opbuf)?.to_vec()),
@@ -240,7 +234,7 @@ pub async fn op_ws_send(
.ok_or_else(bad_resource_id)?;
let mut tx = RcRef::map(&resource, |r| &r.tx).borrow_mut().await;
tx.send(msg).await?;
- Ok(json!({}))
+ Ok(())
}
#[derive(Deserialize)]
@@ -255,7 +249,7 @@ pub async fn op_ws_close(
state: Rc<RefCell<OpState>>,
args: CloseArgs,
_bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<(), AnyError> {
let rid = args.rid;
let msg = Message::Close(args.code.map(|c| CloseFrame {
code: CloseCode::from(c),
@@ -272,24 +266,18 @@ pub async fn op_ws_close(
.ok_or_else(bad_resource_id)?;
let mut tx = RcRef::map(&resource, |r| &r.tx).borrow_mut().await;
tx.send(msg).await?;
- Ok(json!({}))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct NextEventArgs {
- rid: ResourceId,
+ Ok(())
}
pub async fn op_ws_next_event(
state: Rc<RefCell<OpState>>,
- args: NextEventArgs,
+ rid: ResourceId,
_bufs: Option<ZeroCopyBuf>,
) -> Result<Value, AnyError> {
let resource = state
.borrow_mut()
.resource_table
- .get::<WsStreamResource>(args.rid)
+ .get::<WsStreamResource>(rid)
.ok_or_else(bad_resource_id)?;
let mut rx = RcRef::map(&resource, |r| &r.rx).borrow_mut().await;
@@ -325,7 +313,7 @@ pub async fn op_ws_next_event(
Some(Ok(Message::Pong(_))) => json!({ "kind": "pong" }),
Some(Err(_)) => json!({ "kind": "error" }),
None => {
- state.borrow_mut().resource_table.close(args.rid).unwrap();
+ state.borrow_mut().resource_table.close(rid).unwrap();
json!({ "kind": "closed" })
}
};
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 11:54:28 +0000