Implement Send and Sync for OSX's FsWatcher and Windows' ReadDirector…

…yChangesWatcher (closes notify-rs#82)

src/fsevent.rs

@@ -37,6 +37,13 @@ pub struct FsEventWatcher {
     context: Option<Box<StreamContextInfo>>,
 }
 
+// CFMutableArrayRef is a type alias to *mut libc::c_void, so FsEventWatcher is not Send/Sync
+// automatically.
+// It's Send because the pointer is not used in other threads.
+unsafe impl Send for FsEventWatcher {}
+// It's Sync because all methods that change the mutable state use `&mut self`.
+unsafe impl Sync for FsEventWatcher {}
+
 fn translate_flags(flags: fse::StreamFlags) -> op::Op {
     let mut ret = op::Op::empty();
     if flags.contains(fse::ITEM_XATTR_MOD) {

src/windows.rs

@@ -436,3 +436,9 @@ impl Drop for ReadDirectoryChangesWatcher {
         self.wakeup_server();
     }
 }
+
+// `ReadDirectoryChangesWatcher` is not Send/Sync because of the semaphore Handle.
+// As said elsewhere it's perfectly safe to send it accross threads.
+unsafe impl Send for ReadDirectoryChangesWatcher {}
+// Because all public methods are `&mut self` it's also perfectly safe to share references.
+unsafe impl Sync for ReadDirectoryChangesWatcher {}

tests/notify.rs

@@ -230,3 +230,31 @@ fn new_recommended() {
     Err(_) => assert!(false)
   }
 }
+
+// if this test builds, it means RecommendedWatcher is Send.
+#[test]
+fn test_watcher_send() {
+    let (tx, _) = channel();
+
+    let mut watcher: RecommendedWatcher = Watcher::new(tx).unwrap();
+
+    thread::spawn(move || {
+        watcher.watch(".").unwrap();
+    }).join().unwrap();
+}
+
+// if this test builds, it means RecommendedWatcher is Sync.
+#[test]
+fn test_watcher_sync() {
+    use std::sync::{ Arc, RwLock };
+
+    let (tx, _) = channel();
+
+    let watcher: RecommendedWatcher = Watcher::new(tx).unwrap();
+    let watcher = Arc::new(RwLock::new(watcher));
+
+    thread::spawn(move || {
+        let mut watcher = watcher.write().unwrap();
+        watcher.watch(".").unwrap();
+    }).join().unwrap();
+}