Add OsRng wasm support

Author: quininer

.travis.yml

@@ -24,6 +24,13 @@ matrix:
       after_success:
         - travis-cargo --only nightly doc-upload
 
+    - rust: nightly
+      install:
+        - rustup target add wasm32-unknown-unknown
+        - cargo install --force cargo-web
+      script:
+        - cargo web test --target wasm32-unknown-unknown --nodejs
+
 script:
   - cargo test
   - cargo test --tests --no-default-features

Cargo.toml

@@ -48,3 +48,6 @@ cloudabi = "0.0.3"
 
 [target.'cfg(target_os = "fuchsia")'.dependencies]
 fuchsia-zircon = "0.3.2"
+
+[target.wasm32-unknown-unknown.dependencies]
+stdweb = "0.4"

src/lib.rs

@@ -249,6 +249,7 @@
 #![cfg_attr(not(feature="std"), no_std)]
 #![cfg_attr(all(feature="alloc", not(feature="std")), feature(alloc))]
 #![cfg_attr(feature = "i128_support", feature(i128_type, i128))]
+#![cfg_attr(all(target_arch = "wasm32", not(target_os = "emscripten")), recursion_limit="128")]
 
 #[cfg(feature="std")] extern crate std as core;
 #[cfg(all(feature = "alloc", not(feature="std")))] extern crate alloc;
@@ -257,6 +258,10 @@
 #[cfg(feature="serde-1")] extern crate serde;
 #[cfg(feature="serde-1")] #[macro_use] extern crate serde_derive;
 
+#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+#[macro_use]
+extern crate stdweb;
+
 #[cfg(feature = "log")] #[macro_use] extern crate log;
 #[cfg(not(feature = "log"))] macro_rules! trace { ($($x:tt)*) => () }
 #[cfg(not(feature = "log"))] macro_rules! debug { ($($x:tt)*) => () }
@@ -1553,6 +1558,7 @@ mod test {
 
     #[test]
     #[cfg(feature="std")]
+    #[cfg(not(all(target_arch = "wasm32", not(target_os = "emscripten"))))]
     fn test_thread_rng() {
         let mut r = thread_rng();
         r.gen::<i32>();

src/os.rs

@@ -576,27 +576,60 @@ mod imp {
 
 #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
 mod imp {
-    use std::io;
+    use stdweb::unstable::TryInto;
+    use stdweb::web::error::Error as WebError;
+    use {Error, ErrorKind};
 
     #[derive(Debug)]
     pub struct OsRng;
 
     impl OsRng {
         pub fn new() -> Result<OsRng, Error> {
-            Err(Error::new(ErrorKind::Unavailable, "not supported on WASM"))
+            Ok(OsRng)
         }
+
         pub fn try_fill_bytes(&mut self, v: &mut [u8]) -> Result<(), Error> {
-            Err(Error::new(ErrorKind::Unavailable, "not supported on WASM"))
+            let len = v.len() as u32;
+            let ptr = v.as_mut_ptr() as i32;
+
+            let result = js! {
+                let len = @{ len };
+                let ptr = @{ ptr };
+
+                try {
+                    try {
+                        let array = new Uint8Array(len);
+                        window.crypto.getRandomValues(array);
+                        HEAPU8.set(array, ptr);
+                    } catch(err) {
+                        if (err instanceof ReferenceError) {
+                            let bytes = require("crypto").randomBytes(len);
+                            HEAPU8.set(new Uint8Array(bytes), ptr);
+                        } else {
+                            throw err;
+                        }
+                    }
+
+                    return { success: true };
+                } catch(err) {
+                    return { success: false, error: err };
+                }
+            };
+
+            if js!{ return @{ result.as_ref() }.success } == true {
+                Ok(())
+            } else {
+                let err: WebError = js!{ return @{ result }.error }.try_into().unwrap();
+                Err(Error::with_cause(ErrorKind::Other, "WASM Error", err))
+            }
         }
     }
 }
 
 #[cfg(test)]
 mod test {
-    use std::sync::mpsc::channel;
     use RngCore;
     use OsRng;
-    use std::thread;
 
     #[test]
     fn test_os_rng() {
@@ -607,10 +640,18 @@ mod test {
 
         let mut v = [0u8; 1000];
         r.fill_bytes(&mut v);
+
+        let mut v2 = [0u8; 1000];
+        r.fill_bytes(&mut v2);
+
+        assert_ne!(v[..], v2[..]);
     }
 
+    #[cfg(not(any(target_arch = "wasm32", target_arch = "asmjs")))]
     #[test]
     fn test_os_rng_tasks() {
+        use std::sync::mpsc::channel;
+        use std::thread;
 
         let mut txs = vec!();
         for _ in 0..20 {

src/seq.rs

@@ -257,8 +257,8 @@ mod test {
         let mut r = ::test::rng(402);
 
         // sample 0 items
-        assert_eq!(&sample_slice(&mut r, empty, 0)[..], []);
-        assert_eq!(&sample_slice(&mut r, &[42, 2, 42], 0)[..], []);
+        assert_eq!(&sample_slice(&mut r, empty, 0)[..], [0u8; 0]);
+        assert_eq!(&sample_slice(&mut r, &[42, 2, 42], 0)[..], [0u8; 0]);
 
         // sample 1 item
         assert_eq!(&sample_slice(&mut r, &[42], 1)[..], [42]);
@@ -269,12 +269,12 @@ mod test {
         let v = sample_slice(&mut r, &[42, 133], 2);
         assert!(&v[..] == [42, 133] || v[..] == [133, 42]);
 
-        assert_eq!(&sample_indices_inplace(&mut r, 0, 0)[..], []);
-        assert_eq!(&sample_indices_inplace(&mut r, 1, 0)[..], []);
+        assert_eq!(&sample_indices_inplace(&mut r, 0, 0)[..], [0usize; 0]);
+        assert_eq!(&sample_indices_inplace(&mut r, 1, 0)[..], [0usize; 0]);
         assert_eq!(&sample_indices_inplace(&mut r, 1, 1)[..], [0]);
 
-        assert_eq!(&sample_indices_cache(&mut r, 0, 0)[..], []);
-        assert_eq!(&sample_indices_cache(&mut r, 1, 0)[..], []);
+        assert_eq!(&sample_indices_cache(&mut r, 0, 0)[..], [0usize; 0]);
+        assert_eq!(&sample_indices_cache(&mut r, 1, 0)[..], [0usize; 0]);
         assert_eq!(&sample_indices_cache(&mut r, 1, 1)[..], [0]);
 
         // Make sure lucky 777's aren't lucky