Auto merge of servo#164 - Eijebong:serde1.0, r=jdm

bors-servo · web-flow · commit 36e7f5f2ba3e · 2017-06-15T07:58:28.000-07:00
Bump serde to 1.0, bincode to 0.8 and bump version
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ipc-channel"
-version = "0.7.2"
+version = "0.8.0"
 description = "A multiprocess drop-in replacement for Rust channels"
 authors = ["The Servo Project Developers"]
 license = "MIT/Apache-2.0"
@@ -12,12 +12,12 @@ memfd = ["syscall"]
 unstable = []
 
 [dependencies]
-bincode = "1.0.0-alpha2"
+bincode = "0.8"
 lazy_static = "0.2"
 libc = "0.2.12"
 rand = "0.3"
-serde = "0.9"
-uuid = {version = "0.4", features = ["v4"]}
+serde = { version="1.0", features=["rc"] }
+uuid = {version = "0.5", features = ["v4"]}
 fnv = "1.0.3"
 
 [target.'cfg(any(target_os = "linux", target_os = "freebsd"))'.dependencies]
diff --git a/src/ipc.rs b/src/ipc.rs
@@ -37,7 +37,7 @@ thread_local! {
 }
 
 pub fn channel<T>() -> Result<(IpcSender<T>, IpcReceiver<T>),Error>
-                  where T: Deserialize + Serialize {
+                  where T: for<'de> Deserialize<'de> + Serialize {
     let (os_sender, os_receiver) = try!(platform::channel());
     let ipc_receiver = IpcReceiver {
         os_receiver: os_receiver,
@@ -62,12 +62,12 @@ pub fn bytes_channel() -> Result<(IpcBytesSender, IpcBytesReceiver),Error> {
 }
 
 #[derive(Debug)]
-pub struct IpcReceiver<T> where T: Deserialize + Serialize {
+pub struct IpcReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
     os_receiver: OsIpcReceiver,
     phantom: PhantomData<T>,
 }
 
-impl<T> IpcReceiver<T> where T: Deserialize + Serialize {
+impl<T> IpcReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
     pub fn recv(&self) -> Result<T, bincode::Error> {
         let (data, os_ipc_channels, os_ipc_shared_memory_regions) = try!(self.os_receiver.recv());
         OpaqueIpcMessage::new(data, os_ipc_channels, os_ipc_shared_memory_regions).to()
@@ -86,8 +86,8 @@ impl<T> IpcReceiver<T> where T: Deserialize + Serialize {
     }
 }
 
-impl<T> Deserialize for IpcReceiver<T> where T: Deserialize + Serialize {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
+impl<'de, T> Deserialize<'de> for IpcReceiver<T> where T: for<'dde> Deserialize<'dde> + Serialize {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
         let index: usize = try!(Deserialize::deserialize(deserializer));
         let os_receiver =
             OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| {
@@ -102,7 +102,7 @@ impl<T> Deserialize for IpcReceiver<T> where T: Deserialize + Serialize {
     }
 }
 
-impl<T> Serialize for IpcReceiver<T> where T: Deserialize + Serialize {
+impl<T> Serialize for IpcReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
         let index = OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| {
             let mut os_ipc_channels_for_serialization =
@@ -173,8 +173,8 @@ impl<T> IpcSender<T> where T: Serialize {
     }
 }
 
-impl<T> Deserialize for IpcSender<T> where T: Serialize {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
+impl<'de, T> Deserialize<'de> for IpcSender<T> where T: Serialize {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
         let os_sender = try!(deserialize_os_ipc_sender(deserializer));
         Ok(IpcSender {
             os_sender: os_sender,
@@ -201,7 +201,7 @@ impl IpcReceiverSet {
     }
 
     pub fn add<T>(&mut self, receiver: IpcReceiver<T>) -> Result<u64,Error>
-                  where T: Deserialize + Serialize {
+                  where T: for<'de> Deserialize<'de> + Serialize {
         Ok(try!(self.os_receiver_set.add(receiver.os_receiver)))
     }
 
@@ -249,8 +249,8 @@ impl Deref for IpcSharedMemory {
     }
 }
 
-impl Deserialize for IpcSharedMemory {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
+impl<'de> Deserialize<'de> for IpcSharedMemory {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
         let index: usize = try!(Deserialize::deserialize(deserializer));
         let os_shared_memory = OS_IPC_SHARED_MEMORY_REGIONS_FOR_DESERIALIZATION.with(
             |os_ipc_shared_memory_regions_for_deserialization| {
@@ -342,17 +342,15 @@ impl OpaqueIpcMessage {
         }
     }
 
-    pub fn to<T>(mut self) -> Result<T, bincode::Error> where T: Deserialize + Serialize {
+    pub fn to<T>(mut self) -> Result<T, bincode::Error> where T: for<'de> Deserialize<'de> + Serialize {
         OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| {
             OS_IPC_SHARED_MEMORY_REGIONS_FOR_DESERIALIZATION.with(
                     |os_ipc_shared_memory_regions_for_deserialization| {
                 mem::swap(&mut *os_ipc_channels_for_deserialization.borrow_mut(),
                           &mut self.os_ipc_channels);
                 mem::swap(&mut *os_ipc_shared_memory_regions_for_deserialization.borrow_mut(),
                           &mut self.os_ipc_shared_memory_regions);
-                let mut data = &*self.data;
-                let mut deserializer = bincode::Deserializer::new(&mut data, bincode::Infinite);
-                let result = Deserialize::deserialize(&mut deserializer);
+                let result = bincode::deserialize(&self.data[..]);
                 mem::swap(&mut *os_ipc_shared_memory_regions_for_deserialization.borrow_mut(),
                           &mut self.os_ipc_shared_memory_regions);
                 mem::swap(&mut *os_ipc_channels_for_deserialization.borrow_mut(),
@@ -371,16 +369,16 @@ pub struct OpaqueIpcSender {
 }
 
 impl OpaqueIpcSender {
-    pub fn to<T>(self) -> IpcSender<T> where T: Deserialize + Serialize {
+    pub fn to<'de, T>(self) -> IpcSender<T> where T: Deserialize<'de> + Serialize {
         IpcSender {
             os_sender: self.os_sender,
             phantom: PhantomData,
         }
     }
 }
 
-impl Deserialize for OpaqueIpcSender {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
+impl<'de> Deserialize<'de> for OpaqueIpcSender {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
         let os_sender = try!(deserialize_os_ipc_sender(deserializer));
         Ok(OpaqueIpcSender {
             os_sender: os_sender,
@@ -404,7 +402,7 @@ pub struct IpcOneShotServer<T> {
     phantom: PhantomData<T>,
 }
 
-impl<T> IpcOneShotServer<T> where T: Deserialize + Serialize {
+impl<T> IpcOneShotServer<T> where T: for<'de> Deserialize<'de> + Serialize {
     pub fn new() -> Result<(IpcOneShotServer<T>, String),Error> {
         let (os_server, name) = try!(OsIpcOneShotServer::new());
         Ok((IpcOneShotServer {
@@ -446,8 +444,8 @@ impl IpcBytesReceiver {
     }
 }
 
-impl Deserialize for IpcBytesReceiver {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
+impl<'de> Deserialize<'de> for IpcBytesReceiver {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
         let index: usize = try!(Deserialize::deserialize(deserializer));
         let os_receiver =
             OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| {
@@ -488,8 +486,8 @@ impl Clone for IpcBytesSender {
     }
 }
 
-impl Deserialize for IpcBytesSender {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
+impl<'de> Deserialize<'de> for IpcBytesSender {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
         let os_sender = try!(deserialize_os_ipc_sender(deserializer));
         Ok(IpcBytesSender {
             os_sender: os_sender,
@@ -522,8 +520,8 @@ fn serialize_os_ipc_sender<S>(os_ipc_sender: &OsIpcSender, serializer: S)
     index.serialize(serializer)
 }
 
-fn deserialize_os_ipc_sender<D>(deserializer: D)
-                                -> Result<OsIpcSender, D::Error> where D: Deserializer {
+fn deserialize_os_ipc_sender<'de, D>(deserializer: D)
+                                -> Result<OsIpcSender, D::Error> where D: Deserializer<'de> {
     let index: usize = try!(Deserialize::deserialize(deserializer));
     OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| {
         // FIXME(pcwalton): This could panic if the data was corrupt and the index was out of
diff --git a/src/router.rs b/src/router.rs
@@ -47,7 +47,7 @@ impl RouterProxy {
     pub fn route_ipc_receiver_to_mpsc_sender<T>(&self,
                                                 ipc_receiver: IpcReceiver<T>,
                                                 mpsc_sender: Sender<T>)
-                                                where T: Deserialize +
+                                                where T: for<'de> Deserialize<'de> +
                                                          Serialize +
                                                          Send +
                                                          'static {
@@ -60,7 +60,7 @@ impl RouterProxy {
     /// use of a `Router`.
     pub fn route_ipc_receiver_to_new_mpsc_receiver<T>(&self, ipc_receiver: IpcReceiver<T>)
                                                   -> Receiver<T>
-                                                  where T: Deserialize +
+                                                  where T: for<'de> Deserialize<'de> +
                                                            Serialize +
                                                            Send +
                                                            'static {
diff --git a/src/test.rs b/src/test.rs
@@ -406,9 +406,9 @@ impl Serialize for HasWeirdSerializer {
     }
 }
 
-impl Deserialize for HasWeirdSerializer {
+impl<'de> Deserialize<'de> for HasWeirdSerializer {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: Deserializer
+        where D: Deserializer<'de>
     {
         Ok(HasWeirdSerializer(try!(Deserialize::deserialize(deserializer))))
     }

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ thread_local! {`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`pub fn channel<T>() -> Result<(IpcSender<T>, IpcReceiver<T>),Error>`
`40`		`- where T: Deserialize + Serialize {`
	`40`	`+ where T: for<'de> Deserialize<'de> + Serialize {`
`41`	`41`	`let (os_sender, os_receiver) = try!(platform::channel());`
`42`	`42`	`let ipc_receiver = IpcReceiver {`
`43`	`43`	`os_receiver: os_receiver,`
`@@ -62,12 +62,12 @@ pub fn bytes_channel() -> Result<(IpcBytesSender, IpcBytesReceiver),Error> {`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`#[derive(Debug)]`
`65`		`-pub struct IpcReceiver<T> where T: Deserialize + Serialize {`
	`65`	`+pub struct IpcReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {`
`66`	`66`	`os_receiver: OsIpcReceiver,`
`67`	`67`	`phantom: PhantomData<T>,`
`68`	`68`	`}`
`69`	`69`
`70`		`-impl<T> IpcReceiver<T> where T: Deserialize + Serialize {`
	`70`	`+impl<T> IpcReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {`
`71`	`71`	`pub fn recv(&self) -> Result<T, bincode::Error> {`
`72`	`72`	`let (data, os_ipc_channels, os_ipc_shared_memory_regions) = try!(self.os_receiver.recv());`
`73`	`73`	`OpaqueIpcMessage::new(data, os_ipc_channels, os_ipc_shared_memory_regions).to()`
`@@ -86,8 +86,8 @@ impl<T> IpcReceiver<T> where T: Deserialize + Serialize {`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`		`-impl<T> Deserialize for IpcReceiver<T> where T: Deserialize + Serialize {`
`90`		`- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {`
	`89`	`+impl<'de, T> Deserialize<'de> for IpcReceiver<T> where T: for<'dde> Deserialize<'dde> + Serialize {`
	`90`	`+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {`
`91`	`91`	`let index: usize = try!(Deserialize::deserialize(deserializer));`
`92`	`92`	`let os_receiver =`
`93`	`93`	`OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(\|os_ipc_channels_for_deserialization\| {`
`@@ -102,7 +102,7 @@ impl<T> Deserialize for IpcReceiver<T> where T: Deserialize + Serialize {`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`-impl<T> Serialize for IpcReceiver<T> where T: Deserialize + Serialize {`
	`105`	`+impl<T> Serialize for IpcReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {`
`106`	`106`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {`
`107`	`107`	`let index = OS_IPC_CHANNELS_FOR_SERIALIZATION.with(\|os_ipc_channels_for_serialization\| {`
`108`	`108`	`let mut os_ipc_channels_for_serialization =`
`@@ -173,8 +173,8 @@ impl<T> IpcSender<T> where T: Serialize {`
`173`	`173`	`}`
`174`	`174`	`}`
`175`	`175`
`176`		`-impl<T> Deserialize for IpcSender<T> where T: Serialize {`
`177`		`- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {`
	`176`	`+impl<'de, T> Deserialize<'de> for IpcSender<T> where T: Serialize {`
	`177`	`+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {`
`178`	`178`	`let os_sender = try!(deserialize_os_ipc_sender(deserializer));`
`179`	`179`	`Ok(IpcSender {`
`180`	`180`	`os_sender: os_sender,`
`@@ -201,7 +201,7 @@ impl IpcReceiverSet {`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`pub fn add<T>(&mut self, receiver: IpcReceiver<T>) -> Result<u64,Error>`
`204`		`- where T: Deserialize + Serialize {`
	`204`	`+ where T: for<'de> Deserialize<'de> + Serialize {`
`205`	`205`	`Ok(try!(self.os_receiver_set.add(receiver.os_receiver)))`
`206`	`206`	`}`
`207`	`207`
`@@ -249,8 +249,8 @@ impl Deref for IpcSharedMemory {`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`
`252`		`-impl Deserialize for IpcSharedMemory {`
`253`		`- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {`
	`252`	`+impl<'de> Deserialize<'de> for IpcSharedMemory {`
	`253`	`+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {`
`254`	`254`	`let index: usize = try!(Deserialize::deserialize(deserializer));`
`255`	`255`	`let os_shared_memory = OS_IPC_SHARED_MEMORY_REGIONS_FOR_DESERIALIZATION.with(`
`256`	`256`	`\|os_ipc_shared_memory_regions_for_deserialization\| {`
`@@ -342,17 +342,15 @@ impl OpaqueIpcMessage {`
`342`	`342`	`}`
`343`	`343`	`}`
`344`	`344`
`345`		`- pub fn to<T>(mut self) -> Result<T, bincode::Error> where T: Deserialize + Serialize {`
	`345`	`+ pub fn to<T>(mut self) -> Result<T, bincode::Error> where T: for<'de> Deserialize<'de> + Serialize {`
`346`	`346`	`OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(\|os_ipc_channels_for_deserialization\| {`
`347`	`347`	`OS_IPC_SHARED_MEMORY_REGIONS_FOR_DESERIALIZATION.with(`
`348`	`348`	`\|os_ipc_shared_memory_regions_for_deserialization\| {`
`349`	`349`	`mem::swap(&mut *os_ipc_channels_for_deserialization.borrow_mut(),`
`350`	`350`	`&mut self.os_ipc_channels);`
`351`	`351`	`mem::swap(&mut *os_ipc_shared_memory_regions_for_deserialization.borrow_mut(),`
`352`	`352`	`&mut self.os_ipc_shared_memory_regions);`
`353`		`- let mut data = &*self.data;`
`354`		`- let mut deserializer = bincode::Deserializer::new(&mut data, bincode::Infinite);`
`355`		`- let result = Deserialize::deserialize(&mut deserializer);`
	`353`	`+ let result = bincode::deserialize(&self.data[..]);`
`356`	`354`	`mem::swap(&mut *os_ipc_shared_memory_regions_for_deserialization.borrow_mut(),`
`357`	`355`	`&mut self.os_ipc_shared_memory_regions);`
`358`	`356`	`mem::swap(&mut *os_ipc_channels_for_deserialization.borrow_mut(),`
`@@ -371,16 +369,16 @@ pub struct OpaqueIpcSender {`
`371`	`369`	`}`
`372`	`370`
`373`	`371`	`impl OpaqueIpcSender {`
`374`		`- pub fn to<T>(self) -> IpcSender<T> where T: Deserialize + Serialize {`
	`372`	`+ pub fn to<'de, T>(self) -> IpcSender<T> where T: Deserialize<'de> + Serialize {`
`375`	`373`	`IpcSender {`
`376`	`374`	`os_sender: self.os_sender,`
`377`	`375`	`phantom: PhantomData,`
`378`	`376`	`}`
`379`	`377`	`}`
`380`	`378`	`}`
`381`	`379`
`382`		`-impl Deserialize for OpaqueIpcSender {`
`383`		`- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {`
	`380`	`+impl<'de> Deserialize<'de> for OpaqueIpcSender {`
	`381`	`+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {`
`384`	`382`	`let os_sender = try!(deserialize_os_ipc_sender(deserializer));`
`385`	`383`	`Ok(OpaqueIpcSender {`
`386`	`384`	`os_sender: os_sender,`
`@@ -404,7 +402,7 @@ pub struct IpcOneShotServer<T> {`
`404`	`402`	`phantom: PhantomData<T>,`
`405`	`403`	`}`
`406`	`404`
`407`		`-impl<T> IpcOneShotServer<T> where T: Deserialize + Serialize {`
	`405`	`+impl<T> IpcOneShotServer<T> where T: for<'de> Deserialize<'de> + Serialize {`
`408`	`406`	`pub fn new() -> Result<(IpcOneShotServer<T>, String),Error> {`
`409`	`407`	`let (os_server, name) = try!(OsIpcOneShotServer::new());`
`410`	`408`	`Ok((IpcOneShotServer {`
`@@ -446,8 +444,8 @@ impl IpcBytesReceiver {`
`446`	`444`	`}`
`447`	`445`	`}`
`448`	`446`
`449`		`-impl Deserialize for IpcBytesReceiver {`
`450`		`- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {`
	`447`	`+impl<'de> Deserialize<'de> for IpcBytesReceiver {`
	`448`	`+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {`
`451`	`449`	`let index: usize = try!(Deserialize::deserialize(deserializer));`
`452`	`450`	`let os_receiver =`
`453`	`451`	`OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(\|os_ipc_channels_for_deserialization\| {`
`@@ -488,8 +486,8 @@ impl Clone for IpcBytesSender {`
`488`	`486`	`}`
`489`	`487`	`}`
`490`	`488`
`491`		`-impl Deserialize for IpcBytesSender {`
`492`		`- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {`
	`489`	`+impl<'de> Deserialize<'de> for IpcBytesSender {`
	`490`	`+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {`
`493`	`491`	`let os_sender = try!(deserialize_os_ipc_sender(deserializer));`
`494`	`492`	`Ok(IpcBytesSender {`
`495`	`493`	`os_sender: os_sender,`
`@@ -522,8 +520,8 @@ fn serialize_os_ipc_sender<S>(os_ipc_sender: &OsIpcSender, serializer: S)`
`522`	`520`	`index.serialize(serializer)`
`523`	`521`	`}`
`524`	`522`
`525`		`-fn deserialize_os_ipc_sender<D>(deserializer: D)`
`526`		`- -> Result<OsIpcSender, D::Error> where D: Deserializer {`
	`523`	`+fn deserialize_os_ipc_sender<'de, D>(deserializer: D)`
	`524`	`+ -> Result<OsIpcSender, D::Error> where D: Deserializer<'de> {`
`527`	`525`	`let index: usize = try!(Deserialize::deserialize(deserializer));`
`528`	`526`	`OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(\|os_ipc_channels_for_deserialization\| {`
`529`	`527`	`// FIXME(pcwalton): This could panic if the data was corrupt and the index was out of`
Original file line number	Diff line number	Diff line change
`@@ -406,9 +406,9 @@ impl Serialize for HasWeirdSerializer {`
`406`	`406`	`}`
`407`	`407`	`}`
`408`	`408`
`409`		`-impl Deserialize for HasWeirdSerializer {`
	`409`	`+impl<'de> Deserialize<'de> for HasWeirdSerializer {`
`410`	`410`	`fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>`
`411`		`- where D: Deserializer`
	`411`	`+ where D: Deserializer<'de>`
`412`	`412`	`{`
`413`	`413`	`Ok(HasWeirdSerializer(try!(Deserialize::deserialize(deserializer))))`
`414`	`414`	`}`