refactor(serde_v8): split ZeroCopyBuf into JsBuffer and ToJsBuffer (#19566)

`ZeroCopyBuf` was convenient to use, but sometimes it did hide details
that some copies were necessary in certain cases. Also it made it way to easy
for the caller to pass around and convert into different values. This commit
splits `ZeroCopyBuf` into `JsBuffer` (an array buffer coming from V8) and
`ToJsBuffer` (a Rust buffer that will be converted into a V8 array buffer).

As a result some magical conversions were removed (they were never used)
limiting the API surface and preparing for changes in #19534.

1 files changed, 46 insertions, 46 deletions

diff --git a/ext/node/ops/crypto/mod.rs b/ext/node/ops/crypto/mod.rs
index 05f2d34f7..a83263fff 100644
--- a/ext/node/ops/crypto/mod.rs
+++ b/ext/node/ops/crypto/mod.rs
@@ -5,10 +5,11 @@ use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::serde_v8;
 use deno_core::task::spawn_blocking;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::ResourceId;
 use deno_core::StringOrBuffer;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use hkdf::Hkdf;
 use num_bigint::BigInt;
 use num_bigint_dig::BigUint;
@@ -115,7 +116,7 @@ pub fn op_node_hash_update_str(
 pub fn op_node_hash_digest(
   state: &mut OpState,
   rid: ResourceId,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let context = state.resource_table.take::<digest::Context>(rid)?;
   let context = Rc::try_unwrap(context)
     .map_err(|_| type_error("Hash context is already in use"))?;
@@ -148,7 +149,7 @@ pub fn op_node_private_encrypt(
   key: StringOrBuffer,
   msg: StringOrBuffer,
   padding: u32,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let key = RsaPrivateKey::from_pkcs8_pem((&key).try_into()?)?;
 
   let mut rng = rand::thread_rng();
@@ -172,7 +173,7 @@ pub fn op_node_private_decrypt(
   key: StringOrBuffer,
   msg: StringOrBuffer,
   padding: u32,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let key = RsaPrivateKey::from_pkcs8_pem((&key).try_into()?)?;
 
   match padding {
@@ -195,7 +196,7 @@ pub fn op_node_public_encrypt(
   key: StringOrBuffer,
   msg: StringOrBuffer,
   padding: u32,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let key = RsaPublicKey::from_public_key_pem((&key).try_into()?)?;
 
   let mut rng = rand::thread_rng();
@@ -307,7 +308,7 @@ pub fn op_node_sign(
   key: StringOrBuffer,
   key_type: &str,
   key_format: &str,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   match key_type {
     "rsa" => {
       use rsa::pkcs1v15::SigningKey;
@@ -456,7 +457,7 @@ pub async fn op_node_pbkdf2_async(
   iterations: u32,
   digest: String,
   keylen: usize,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   spawn_blocking(move || {
     let mut derived_key = vec![0; keylen];
     pbkdf2_sync(&password, &salt, iterations, &digest, &mut derived_key)
@@ -471,7 +472,7 @@ pub fn op_node_generate_secret(buf: &mut [u8]) {
 }
 
 #[op]
-pub async fn op_node_generate_secret_async(len: i32) -> ZeroCopyBuf {
+pub async fn op_node_generate_secret_async(len: i32) -> ToJsBuffer {
   spawn_blocking(move || {
     let mut buf = vec![0u8; len as usize];
     rand::thread_rng().fill(&mut buf[..]);
@@ -525,11 +526,11 @@ pub fn op_node_hkdf(
 #[op]
 pub async fn op_node_hkdf_async(
   hash: String,
-  ikm: ZeroCopyBuf,
-  salt: ZeroCopyBuf,
-  info: ZeroCopyBuf,
+  ikm: JsBuffer,
+  salt: JsBuffer,
+  info: JsBuffer,
   okm_len: usize,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   spawn_blocking(move || {
     let mut okm = vec![0u8; okm_len];
     hkdf_sync(&hash, &ikm, &salt, &info, &mut okm)?;
@@ -546,7 +547,7 @@ use self::primes::Prime;
 fn generate_rsa(
   modulus_length: usize,
   public_exponent: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   let mut rng = rand::thread_rng();
   let private_key = RsaPrivateKey::new_with_exp(
     &mut rng,
@@ -564,7 +565,7 @@ fn generate_rsa(
 pub fn op_node_generate_rsa(
   modulus_length: usize,
   public_exponent: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   generate_rsa(modulus_length, public_exponent)
 }
 
@@ -572,14 +573,14 @@ pub fn op_node_generate_rsa(
 pub async fn op_node_generate_rsa_async(
   modulus_length: usize,
   public_exponent: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || generate_rsa(modulus_length, public_exponent)).await?
 }
 
 fn dsa_generate(
   modulus_length: usize,
   divisor_length: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   let mut rng = rand::thread_rng();
   use dsa::pkcs8::EncodePrivateKey;
   use dsa::pkcs8::EncodePublicKey;
@@ -618,7 +619,7 @@ fn dsa_generate(
 pub fn op_node_dsa_generate(
   modulus_length: usize,
   divisor_length: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   dsa_generate(modulus_length, divisor_length)
 }
 
@@ -626,13 +627,13 @@ pub fn op_node_dsa_generate(
 pub async fn op_node_dsa_generate_async(
   modulus_length: usize,
   divisor_length: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || dsa_generate(modulus_length, divisor_length)).await?
 }
 
 fn ec_generate(
   named_curve: &str,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   use ring::signature::EcdsaKeyPair;
   use ring::signature::KeyPair;
 
@@ -658,18 +659,18 @@ fn ec_generate(
 #[op]
 pub fn op_node_ec_generate(
   named_curve: &str,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   ec_generate(named_curve)
 }
 
 #[op]
 pub async fn op_node_ec_generate_async(
   named_curve: String,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || ec_generate(&named_curve)).await?
 }
 
-fn ed25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+fn ed25519_generate() -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   use ring::signature::Ed25519KeyPair;
   use ring::signature::KeyPair;
 
@@ -685,18 +686,18 @@ fn ed25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
 }
 
 #[op]
-pub fn op_node_ed25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError>
+pub fn op_node_ed25519_generate() -> Result<(ToJsBuffer, ToJsBuffer), AnyError>
 {
   ed25519_generate()
 }
 
 #[op]
 pub async fn op_node_ed25519_generate_async(
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(ed25519_generate).await?
 }
 
-fn x25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+fn x25519_generate() -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   // u-coordinate of the base point.
   const X25519_BASEPOINT_BYTES: [u8; 32] = [
     9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -720,20 +721,19 @@ fn x25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
 }
 
 #[op]
-pub fn op_node_x25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError>
-{
+pub fn op_node_x25519_generate() -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   x25519_generate()
 }
 
 #[op]
 pub async fn op_node_x25519_generate_async(
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(x25519_generate).await?
 }
 
 fn dh_generate_group(
   group_name: &str,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   let dh = match group_name {
     "modp5" => dh::DiffieHellman::group::<dh::Modp1536>(),
     "modp14" => dh::DiffieHellman::group::<dh::Modp2048>(),
@@ -753,14 +753,14 @@ fn dh_generate_group(
 #[op]
 pub fn op_node_dh_generate_group(
   group_name: &str,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   dh_generate_group(group_name)
 }
 
 #[op]
 pub async fn op_node_dh_generate_group_async(
   group_name: String,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || dh_generate_group(&group_name)).await?
 }
 
@@ -768,7 +768,7 @@ fn dh_generate(
   prime: Option<&[u8]>,
   prime_len: usize,
   generator: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   let prime = prime
     .map(|p| p.into())
     .unwrap_or_else(|| Prime::generate(prime_len));
@@ -785,26 +785,26 @@ pub fn op_node_dh_generate(
   prime: Option<&[u8]>,
   prime_len: usize,
   generator: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   dh_generate(prime, prime_len, generator)
 }
 
 // TODO(lev): This duplication should be avoided.
 #[op]
 pub fn op_node_dh_generate2(
-  prime: ZeroCopyBuf,
+  prime: JsBuffer,
   prime_len: usize,
   generator: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   dh_generate(Some(prime).as_deref(), prime_len, generator)
 }
 
 #[op]
 pub fn op_node_dh_compute_secret(
-  prime: ZeroCopyBuf,
-  private_key: ZeroCopyBuf,
-  their_public_key: ZeroCopyBuf,
-) -> Result<ZeroCopyBuf, AnyError> {
+  prime: JsBuffer,
+  private_key: JsBuffer,
+  their_public_key: JsBuffer,
+) -> Result<ToJsBuffer, AnyError> {
   let pubkey: BigUint = BigUint::from_bytes_be(their_public_key.as_ref());
   let privkey: BigUint = BigUint::from_bytes_be(private_key.as_ref());
   let primei: BigUint = BigUint::from_bytes_be(prime.as_ref());
@@ -815,10 +815,10 @@ pub fn op_node_dh_compute_secret(
 
 #[op]
 pub async fn op_node_dh_generate_async(
-  prime: Option<ZeroCopyBuf>,
+  prime: Option<JsBuffer>,
   prime_len: usize,
   generator: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || dh_generate(prime.as_deref(), prime_len, generator))
     .await?
 }
@@ -895,7 +895,7 @@ pub async fn op_node_scrypt_async(
   block_size: u32,
   parallelization: u32,
   maxmem: u32,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   spawn_blocking(move || {
     let mut output_buffer = vec![0u8; keylen as usize];
     let res = scrypt(
@@ -963,7 +963,7 @@ pub fn op_node_ecdh_generate_keys(
 #[op]
 pub fn op_node_ecdh_compute_secret(
   curve: &str,
-  this_priv: Option<ZeroCopyBuf>,
+  this_priv: Option<JsBuffer>,
   their_pub: &mut [u8],
   secret: &mut [u8],
 ) -> Result<(), AnyError> {
@@ -1079,18 +1079,18 @@ pub fn op_node_ecdh_compute_public_key(
 }
 
 #[inline]
-fn gen_prime(size: usize) -> ZeroCopyBuf {
+fn gen_prime(size: usize) -> ToJsBuffer {
   primes::Prime::generate(size).0.to_bytes_be().into()
 }
 
 #[op]
-pub fn op_node_gen_prime(size: usize) -> ZeroCopyBuf {
+pub fn op_node_gen_prime(size: usize) -> ToJsBuffer {
   gen_prime(size)
 }
 
 #[op]
 pub async fn op_node_gen_prime_async(
   size: usize,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   Ok(spawn_blocking(move || gen_prime(size)).await?)
 }