6 files changed, 326 insertions, 5 deletions

diff --git a/serde_v8/src/de.rs b/serde_v8/src/de.rs
index 4de2f5817..f351d7870 100644
--- a/serde_v8/src/de.rs
+++ b/serde_v8/src/de.rs
@@ -309,6 +309,16 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
       return visitor.visit_u64(hack);
     }
 
+    // Magic Buffer
+    if name == magic::buffer::BUF_NAME {
+      let zero_copy_buf =
+        v8::Local::<v8::ArrayBufferView>::try_from(self.input)
+          .map(|view| magic::zero_copy_buf::ZeroCopyBuf::new(self.scope, view))
+          .map_err(|_| Error::ExpectedArray)?;
+      let data: [u8; 32] = unsafe { std::mem::transmute(zero_copy_buf) };
+      return visitor.visit_bytes(&data);
+    }
+
     // Regular struct
     let obj = v8::Local::<v8::Object>::try_from(self.input).unwrap();
     let map = ObjectAccess {
diff --git a/serde_v8/src/lib.rs b/serde_v8/src/lib.rs
index 2017f0e87..93ad4908f 100644
--- a/serde_v8/src/lib.rs
+++ b/serde_v8/src/lib.rs
@@ -11,6 +11,7 @@ pub mod utils;
 pub use de::{from_v8, from_v8_cached, Deserializer};
 pub use error::{Error, Result};
 pub use keys::KeyCache;
+pub use magic::buffer::MagicBuffer as Buffer;
 pub use magic::Value;
 pub use ser::{to_v8, Serializer};
 pub use serializable::{Serializable, SerializablePkg};
diff --git a/serde_v8/src/magic/buffer.rs b/serde_v8/src/magic/buffer.rs
new file mode 100644
index 000000000..893bf35e1
--- /dev/null
+++ b/serde_v8/src/magic/buffer.rs
@@ -0,0 +1,132 @@
+use rusty_v8 as v8;
+
+use std::cell::Cell;
+use std::fmt;
+use std::ops::Deref;
+use std::ops::DerefMut;
+
+use super::zero_copy_buf::ZeroCopyBuf;
+
+// An asymmetric wrapper around ZeroCopyBuf,
+// allowing us to use a single type for familiarity
+pub enum MagicBuffer {
+  FromV8(ZeroCopyBuf),
+  ToV8(Cell<Option<Box<[u8]>>>),
+}
+
+impl MagicBuffer {
+  pub fn new<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    view: v8::Local<v8::ArrayBufferView>,
+  ) -> Self {
+    Self::FromV8(ZeroCopyBuf::new(scope, view))
+  }
+}
+
+impl Clone for MagicBuffer {
+  fn clone(&self) -> Self {
+    match self {
+      Self::FromV8(zbuf) => Self::FromV8(zbuf.clone()),
+      Self::ToV8(_) => panic!("Don't Clone a MagicBuffer sent to v8"),
+    }
+  }
+}
+
+impl AsRef<[u8]> for MagicBuffer {
+  fn as_ref(&self) -> &[u8] {
+    &*self
+  }
+}
+
+impl AsMut<[u8]> for MagicBuffer {
+  fn as_mut(&mut self) -> &mut [u8] {
+    &mut *self
+  }
+}
+
+impl Deref for MagicBuffer {
+  type Target = [u8];
+  fn deref(&self) -> &[u8] {
+    match self {
+      Self::FromV8(buf) => &*buf,
+      Self::ToV8(_) => panic!("Don't Deref a MagicBuffer sent to v8"),
+    }
+  }
+}
+
+impl DerefMut for MagicBuffer {
+  fn deref_mut(&mut self) -> &mut [u8] {
+    match self {
+      Self::FromV8(buf) => &mut *buf,
+      Self::ToV8(_) => panic!("Don't Deref a MagicBuffer sent to v8"),
+    }
+  }
+}
+
+impl From<Box<[u8]>> for MagicBuffer {
+  fn from(buf: Box<[u8]>) -> Self {
+    MagicBuffer::ToV8(Cell::new(Some(buf)))
+  }
+}
+
+impl From<Vec<u8>> for MagicBuffer {
+  fn from(vec: Vec<u8>) -> Self {
+    vec.into_boxed_slice().into()
+  }
+}
+
+pub const BUF_NAME: &str = "$__v8_magic_Buffer";
+pub const BUF_FIELD_1: &str = "$__v8_magic_buffer_1";
+pub const BUF_FIELD_2: &str = "$__v8_magic_buffer_2";
+
+impl serde::Serialize for MagicBuffer {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: serde::Serializer,
+  {
+    use serde::ser::SerializeStruct;
+
+    let mut s = serializer.serialize_struct(BUF_NAME, 1)?;
+    let boxed: Box<[u8]> = match self {
+      Self::FromV8(_) => unreachable!(),
+      Self::ToV8(x) => x.take().expect("MagicBuffer was empty"),
+    };
+    let hack: [usize; 2] = unsafe { std::mem::transmute(boxed) };
+    let f1: u64 = hack[0] as u64;
+    let f2: u64 = hack[1] as u64;
+    s.serialize_field(BUF_FIELD_1, &f1)?;
+    s.serialize_field(BUF_FIELD_2, &f2)?;
+    s.end()
+  }
+}
+
+impl<'de, 's> serde::Deserialize<'de> for MagicBuffer {
+  fn deserialize<D>(deserializer: D) -> Result<MagicBuffer, D::Error>
+  where
+    D: serde::Deserializer<'de>,
+  {
+    struct ValueVisitor {}
+
+    impl<'de> serde::de::Visitor<'de> for ValueVisitor {
+      type Value = MagicBuffer;
+
+      fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a serde_v8::MagicBuffer")
+      }
+
+      fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+      where
+        E: serde::de::Error,
+      {
+        let p1: &[usize] = unsafe { &*(v as *const [u8] as *const [usize]) };
+        let p2: [usize; 4] = [p1[0], p1[1], p1[2], p1[3]];
+        let zero_copy: ZeroCopyBuf = unsafe { std::mem::transmute(p2) };
+        Ok(MagicBuffer::FromV8(zero_copy))
+      }
+    }
+
+    static FIELDS: [&str; 0] = [];
+    let visitor = ValueVisitor {};
+    deserializer.deserialize_struct(BUF_NAME, &FIELDS, visitor)
+  }
+}
diff --git a/serde_v8/src/magic/mod.rs b/serde_v8/src/magic/mod.rs
index 50a971939..29c35a831 100644
--- a/serde_v8/src/magic/mod.rs
+++ b/serde_v8/src/magic/mod.rs
@@ -1,6 +1,8 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+pub mod buffer;
 mod field;
 mod value;
+pub mod zero_copy_buf;
 
 pub use field::FieldSerializer;
 pub use value::{Value, FIELD, NAME};
diff --git a/serde_v8/src/magic/zero_copy_buf.rs b/serde_v8/src/magic/zero_copy_buf.rs
new file mode 100644
index 000000000..1f07292ba
--- /dev/null
+++ b/serde_v8/src/magic/zero_copy_buf.rs
@@ -0,0 +1,102 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+
+use rusty_v8 as v8;
+use std::cell::Cell;
+use std::ops::Deref;
+use std::ops::DerefMut;
+
+/// A ZeroCopyBuf encapsulates a slice that's been borrowed from a JavaScript
+/// ArrayBuffer object. JavaScript objects can normally be garbage collected,
+/// but the existence of a ZeroCopyBuf inhibits this until it is dropped. It
+/// behaves much like an Arc<[u8]>.
+///
+/// # Cloning
+/// Cloning a ZeroCopyBuf does not clone the contents of the buffer,
+/// it creates a new reference to that buffer.
+///
+/// To actually clone the contents of the buffer do
+/// `let copy = Vec::from(&*zero_copy_buf);`
+#[derive(Clone)]
+pub struct ZeroCopyBuf {
+  backing_store: v8::SharedRef<v8::BackingStore>,
+  byte_offset: usize,
+  byte_length: usize,
+}
+
+unsafe impl Send for ZeroCopyBuf {}
+
+impl ZeroCopyBuf {
+  pub fn new<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    view: v8::Local<v8::ArrayBufferView>,
+  ) -> Self {
+    let backing_store = view.buffer(scope).unwrap().get_backing_store();
+    let byte_offset = view.byte_offset();
+    let byte_length = view.byte_length();
+    Self {
+      backing_store,
+      byte_offset,
+      byte_length,
+    }
+  }
+}
+
+impl Deref for ZeroCopyBuf {
+  type Target = [u8];
+  fn deref(&self) -> &[u8] {
+    unsafe {
+      get_backing_store_slice(
+        &self.backing_store,
+        self.byte_offset,
+        self.byte_length,
+      )
+    }
+  }
+}
+
+impl DerefMut for ZeroCopyBuf {
+  fn deref_mut(&mut self) -> &mut [u8] {
+    unsafe {
+      get_backing_store_slice_mut(
+        &self.backing_store,
+        self.byte_offset,
+        self.byte_length,
+      )
+    }
+  }
+}
+
+impl AsRef<[u8]> for ZeroCopyBuf {
+  fn as_ref(&self) -> &[u8] {
+    &*self
+  }
+}
+
+impl AsMut<[u8]> for ZeroCopyBuf {
+  fn as_mut(&mut self) -> &mut [u8] {
+    &mut *self
+  }
+}
+
+unsafe fn get_backing_store_slice(
+  backing_store: &v8::SharedRef<v8::BackingStore>,
+  byte_offset: usize,
+  byte_length: usize,
+) -> &[u8] {
+  let cells: *const [Cell<u8>] =
+    &backing_store[byte_offset..byte_offset + byte_length];
+  let bytes = cells as *const [u8];
+  &*bytes
+}
+
+#[allow(clippy::mut_from_ref)]
+unsafe fn get_backing_store_slice_mut(
+  backing_store: &v8::SharedRef<v8::BackingStore>,
+  byte_offset: usize,
+  byte_length: usize,
+) -> &mut [u8] {
+  let cells: *const [Cell<u8>] =
+    &backing_store[byte_offset..byte_offset + byte_length];
+  let bytes = cells as *const _ as *mut [u8];
+  &mut *bytes
+}
diff --git a/serde_v8/src/ser.rs b/serde_v8/src/ser.rs
index bc0dfaa22..b0f1a5e7d 100644
--- a/serde_v8/src/ser.rs
+++ b/serde_v8/src/ser.rs
@@ -224,9 +224,55 @@ impl<'a> ser::SerializeStruct for MagicSerializer<'a> {
   }
 }
 
+// TODO(@AaronO): refactor this and streamline how we transmute values
+pub struct MagicBufferSerializer<'a, 'b, 'c> {
+  scope: ScopePtr<'a, 'b, 'c>,
+  f1: u64,
+  f2: u64,
+}
+
+impl<'a, 'b, 'c> MagicBufferSerializer<'a, 'b, 'c> {
+  pub fn new(scope: ScopePtr<'a, 'b, 'c>) -> Self {
+    Self {
+      scope,
+      f1: 0,
+      f2: 0,
+    }
+  }
+}
+
+impl<'a, 'b, 'c> ser::SerializeStruct for MagicBufferSerializer<'a, 'b, 'c> {
+  type Ok = JsValue<'a>;
+  type Error = Error;
+
+  fn serialize_field<T: ?Sized + Serialize>(
+    &mut self,
+    key: &'static str,
+    value: &T,
+  ) -> Result<()> {
+    // Get u64 chunk
+    let transmuted: u64 = value.serialize(magic::FieldSerializer {})?;
+    match key {
+      magic::buffer::BUF_FIELD_1 => self.f1 = transmuted,
+      magic::buffer::BUF_FIELD_2 => self.f2 = transmuted,
+      _ => unreachable!(),
+    }
+    Ok(())
+  }
+
+  fn end(self) -> JsResult<'a> {
+    let x: [usize; 2] = [self.f1 as usize, self.f2 as usize];
+    let buf: Box<[u8]> = unsafe { std::mem::transmute(x) };
+    let scope = &mut *self.scope.borrow_mut();
+    let v8_value = boxed_slice_to_uint8array(scope, buf);
+    Ok(v8_value.into())
+  }
+}
+
 // Dispatches between magic and regular struct serializers
 pub enum StructSerializers<'a, 'b, 'c> {
   Magic(MagicSerializer<'a>),
+  MagicBuffer(MagicBufferSerializer<'a, 'b, 'c>),
   Regular(ObjectSerializer<'a, 'b, 'c>),
 }
 
@@ -241,6 +287,7 @@ impl<'a, 'b, 'c> ser::SerializeStruct for StructSerializers<'a, 'b, 'c> {
   ) -> Result<()> {
     match self {
       StructSerializers::Magic(s) => s.serialize_field(key, value),
+      StructSerializers::MagicBuffer(s) => s.serialize_field(key, value),
       StructSerializers::Regular(s) => s.serialize_field(key, value),
     }
   }
@@ -248,6 +295,7 @@ impl<'a, 'b, 'c> ser::SerializeStruct for StructSerializers<'a, 'b, 'c> {
   fn end(self) -> JsResult<'a> {
     match self {
       StructSerializers::Magic(s) => s.end(),
+      StructSerializers::MagicBuffer(s) => s.end(),
       StructSerializers::Regular(s) => s.end(),
     }
   }
@@ -463,12 +511,20 @@ impl<'a, 'b, 'c> ser::Serializer for Serializer<'a, 'b, 'c> {
     name: &'static str,
     _len: usize,
   ) -> Result<Self::SerializeStruct> {
-    if name == magic::NAME {
-      let m: MagicSerializer<'a> = MagicSerializer { v8_value: None };
-      return Ok(StructSerializers::Magic(m));
+    match name {
+      magic::NAME => {
+        let m: MagicSerializer<'a> = MagicSerializer { v8_value: None };
+        Ok(StructSerializers::Magic(m))
+      }
+      magic::buffer::BUF_NAME => {
+        let m = MagicBufferSerializer::new(self.scope);
+        Ok(StructSerializers::MagicBuffer(m))
+      }
+      _ => {
+        let o = ObjectSerializer::new(self.scope);
+        Ok(StructSerializers::Regular(o))
+      }
     }
-    let o = ObjectSerializer::new(self.scope);
-    Ok(StructSerializers::Regular(o))
   }
 
   fn serialize_struct_variant(
@@ -483,3 +539,21 @@ impl<'a, 'b, 'c> ser::Serializer for Serializer<'a, 'b, 'c> {
     Ok(VariantSerializer::new(scope, variant, x))
   }
 }
+
+// Used to map MagicBuffers to v8
+pub fn boxed_slice_to_uint8array<'a>(
+  scope: &mut v8::HandleScope<'a>,
+  buf: Box<[u8]>,
+) -> v8::Local<'a, v8::Uint8Array> {
+  if buf.is_empty() {
+    let ab = v8::ArrayBuffer::new(scope, 0);
+    return v8::Uint8Array::new(scope, ab, 0, 0)
+      .expect("Failed to create UintArray8");
+  }
+  let buf_len = buf.len();
+  let backing_store = v8::ArrayBuffer::new_backing_store_from_boxed_slice(buf);
+  let backing_store_shared = backing_store.make_shared();
+  let ab = v8::ArrayBuffer::with_backing_store(scope, &backing_store_shared);
+  v8::Uint8Array::new(scope, ab, 0, buf_len)
+    .expect("Failed to create UintArray8")
+}