Implement Clone for SharedRef<T> (#241)

src/array_buffer.rs

@@ -49,6 +49,9 @@ extern "C" {
   fn v8__BackingStore__IsShared(this: *const BackingStore) -> bool;
   fn v8__BackingStore__DELETE(this: &mut BackingStore);
 
+  fn std__shared_ptr__v8__BackingStore__COPY(
+    ptr: *const SharedRef<BackingStore>,
+  ) -> SharedRef<BackingStore>;
   fn std__shared_ptr__v8__BackingStore__CONVERT__std__unique_ptr(
     unique: UniqueRef<BackingStore>,
   ) -> SharedRef<BackingStore>;
@@ -180,6 +183,9 @@ impl Delete for BackingStore {
 }
 
 impl Shared for BackingStore {
+  fn clone(ptr: *const SharedRef<Self>) -> SharedRef<Self> {
+    unsafe { std__shared_ptr__v8__BackingStore__COPY(ptr) }
+  }
   fn from_unique(unique: UniqueRef<Self>) -> SharedRef<Self> {
     unsafe {
       std__shared_ptr__v8__BackingStore__CONVERT__std__unique_ptr(unique)

src/binding.cc

@@ -592,6 +592,11 @@ bool v8__BackingStore__IsShared(const v8::BackingStore& self) {
 
 void v8__BackingStore__DELETE(v8::BackingStore& self) { delete &self; }
 
+two_pointers_t std__shared_ptr__v8__BackingStore__COPY(
+    const std::shared_ptr<v8::BackingStore>& ptr) {
+  return make_pod<two_pointers_t>(ptr);
+}
+
 two_pointers_t std__shared_ptr__v8__BackingStore__CONVERT__std__unique_ptr(
     v8::BackingStore* ptr) {
   return make_pod<two_pointers_t>(std::shared_ptr<v8::BackingStore>(ptr));

src/support.rs

@@ -161,6 +161,7 @@ pub trait Shared
 where
   Self: Delete + 'static,
 {
+  fn clone(shared_ptr: *const SharedRef<Self>) -> SharedRef<Self>;
   fn from_unique(unique: UniqueRef<Self>) -> SharedRef<Self>;
   fn deref(shared_ptr: *const SharedRef<Self>) -> *mut Self;
   fn reset(shared_ptr: *mut SharedRef<Self>);
@@ -185,6 +186,15 @@ where
   }
 }
 
+impl<T> Clone for SharedRef<T>
+where
+  T: Shared,
+{
+  fn clone(&self) -> Self {
+    <T as Shared>::clone(self)
+  }
+}
+
 impl<T> From<UniqueRef<T>> for SharedRef<T>
 where
   T: Delete + Shared,

tests/test_api.rs

@@ -342,11 +342,20 @@ fn array_buffer_with_shared_backing_store() {
 
     let bs4 = ab2.get_backing_store();
     assert_eq!(ab2.byte_length(), bs4.byte_length());
-    assert_eq!(4, v8::SharedRef::use_count(&bs4));
     assert_eq!(4, v8::SharedRef::use_count(&bs3));
+    assert_eq!(4, v8::SharedRef::use_count(&bs4));
+
+    let bs5 = bs4.clone();
+    assert_eq!(5, v8::SharedRef::use_count(&bs3));
+    assert_eq!(5, v8::SharedRef::use_count(&bs4));
+    assert_eq!(5, v8::SharedRef::use_count(&bs5));
 
     drop(bs3);
-    assert_eq!(3, v8::SharedRef::use_count(&bs4));
+    assert_eq!(4, v8::SharedRef::use_count(&bs4));
+    assert_eq!(4, v8::SharedRef::use_count(&bs4));
+
+    drop(bs4);
+    assert_eq!(3, v8::SharedRef::use_count(&bs5));
   }
 }