libextra: Another round of de-`Cell`-ing.

34 uses of `Cell` remain.

3 files changed, 45 insertions, 93 deletions

diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index aa7a64d2210..122ededfbc3 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -146,7 +146,6 @@ impl Acceptor<TcpStream> for TcpAcceptor {
 #[cfg(test)]
 mod test {
     use super::*;
-    use cell::Cell;
     use rt::test::*;
     use io::net::ip::{Ipv4Addr, SocketAddr};
     use io::*;
@@ -196,12 +195,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 stream.read(buf);
@@ -209,7 +206,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]);
             }
@@ -221,12 +218,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 stream.read(buf);
@@ -234,7 +229,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]);
             }
@@ -246,12 +241,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -259,7 +252,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -271,12 +264,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -284,7 +275,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -296,12 +287,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -319,7 +308,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -331,12 +320,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -354,7 +341,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -366,12 +353,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let buf = [0];
                 loop {
@@ -392,7 +377,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -404,12 +389,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let buf = [0];
                 loop {
@@ -430,7 +413,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -443,12 +426,10 @@ mod test {
             let addr = next_test_ip4();
             let max = 10;
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for ref mut stream in acceptor.incoming().take(max) {
                     let mut buf = [0];
                     stream.read(buf);
@@ -457,7 +438,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 max.times(|| {
                     let mut stream = TcpStream::connect(addr);
                     stream.write([99]);
@@ -472,12 +453,10 @@ mod test {
             let addr = next_test_ip6();
             let max = 10;
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for ref mut stream in acceptor.incoming().take(max) {
                     let mut buf = [0];
                     stream.read(buf);
@@ -486,7 +465,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 max.times(|| {
                     let mut stream = TcpStream::connect(addr);
                     stream.write([99]);
@@ -501,16 +480,14 @@ mod test {
             let addr = next_test_ip4();
             static MAX: int = 10;
             let (port, chan) = oneshot();
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                    let stream = Cell::new(stream);
                     // Start another task to handle the connection
                     do spawntask {
-                        let mut stream = stream.take();
+                        let mut stream = stream;
                         let mut buf = [0];
                         stream.read(buf);
                         assert!(buf[0] == i as u8);
@@ -543,16 +520,14 @@ mod test {
             let addr = next_test_ip6();
             static MAX: int = 10;
             let (port, chan) = oneshot();
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                    let stream = Cell::new(stream);
                     // Start another task to handle the connection
                     do spawntask {
-                        let mut stream = stream.take();
+                        let mut stream = stream;
                         let mut buf = [0];
                         stream.read(buf);
                         assert!(buf[0] == i as u8);
@@ -585,16 +560,14 @@ mod test {
             let addr = next_test_ip4();
             static MAX: int = 10;
             let (port, chan) = oneshot();
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for stream in acceptor.incoming().take(MAX as uint) {
-                    let stream = Cell::new(stream);
                     // Start another task to handle the connection
                     do spawntask_later {
-                        let mut stream = stream.take();
+                        let mut stream = stream;
                         let mut buf = [0];
                         stream.read(buf);
                         assert!(buf[0] == 99);
@@ -626,16 +599,14 @@ mod test {
             let addr = next_test_ip6();
             static MAX: int = 10;
             let (port, chan) = oneshot();
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for stream in acceptor.incoming().take(MAX as uint) {
-                    let stream = Cell::new(stream);
                     // Start another task to handle the connection
                     do spawntask_later {
-                        let mut stream = stream.take();
+                        let mut stream = stream;
                         let mut buf = [0];
                         stream.read(buf);
                         assert!(buf[0] == 99);
@@ -682,18 +653,16 @@ mod test {
     fn peer_name(addr: SocketAddr) {
         do run_in_mt_newsched_task {
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
 
                 acceptor.accept();
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let stream = TcpStream::connect(addr);
 
                 assert!(stream.is_some());
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index f02fc1ae447..2e07269ed0c 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -110,7 +110,6 @@ mod test {
     use io::*;
     use option::{Some, None};
     use rt::comm::oneshot;
-    use cell::Cell;
 
     #[test]  #[ignore]
     fn bind_error() {
@@ -134,13 +133,11 @@ mod test {
             let server_ip = next_test_ip4();
             let client_ip = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(ref mut server) => {
-                        chan.take().send(());
+                        chan.send(());
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -158,7 +155,7 @@ mod test {
             do spawntask {
                 match UdpSocket::bind(client_ip) {
                     Some(ref mut client) => {
-                        port.take().recv();
+                        port.recv();
                         client.sendto([99], server_ip)
                     }
                     None => fail!()
@@ -173,13 +170,11 @@ mod test {
             let server_ip = next_test_ip6();
             let client_ip = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(ref mut server) => {
-                        chan.take().send(());
+                        chan.send(());
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -197,7 +192,7 @@ mod test {
             do spawntask {
                 match UdpSocket::bind(client_ip) {
                     Some(ref mut client) => {
-                        port.take().recv();
+                        port.recv();
                         client.sendto([99], server_ip)
                     }
                     None => fail!()
@@ -212,15 +207,13 @@ mod test {
             let server_ip = next_test_ip4();
             let client_ip = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(server) => {
                         let server = ~server;
                         let mut stream = server.connect(client_ip);
-                        chan.take().send(());
+                        chan.send(());
                         let mut buf = [0];
                         match stream.read(buf) {
                             Some(nread) => {
@@ -239,7 +232,7 @@ mod test {
                     Some(client) => {
                         let client = ~client;
                         let mut stream = client.connect(server_ip);
-                        port.take().recv();
+                        port.recv();
                         stream.write([99]);
                     }
                     None => fail!()
@@ -254,15 +247,13 @@ mod test {
             let server_ip = next_test_ip6();
             let client_ip = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(server) => {
                         let server = ~server;
                         let mut stream = server.connect(client_ip);
-                        chan.take().send(());
+                        chan.send(());
                         let mut buf = [0];
                         match stream.read(buf) {
                             Some(nread) => {
@@ -281,7 +272,7 @@ mod test {
                     Some(client) => {
                         let client = ~client;
                         let mut stream = client.connect(server_ip);
-                        port.take().recv();
+                        port.recv();
                         stream.write([99]);
                     }
                     None => fail!()
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index 6d2deccaa4c..7cbf3108a80 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -152,32 +152,26 @@ impl Acceptor<UnixStream> for UnixAcceptor {
 mod tests {
     use prelude::*;
     use super::*;
-    use cell::Cell;
     use rt::test::*;
     use io::*;
     use rt::comm::oneshot;
 
     fn smalltest(server: proc(UnixStream), client: proc(UnixStream)) {
-        let server = Cell::new(server);
-        let client = Cell::new(client);
         do run_in_mt_newsched_task {
-            let server = Cell::new(server.take());
-            let client = Cell::new(client.take());
             let path1 = next_test_unix();
             let path2 = path1.clone();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
+            let (client, server) = (client, server);
 
             do spawntask {
                 let mut acceptor = UnixListener::bind(&path1).listen();
-                chan.take().send(());
-                server.take()(acceptor.accept().unwrap());
+                chan.send(());
+                server(acceptor.accept().unwrap());
             }
 
             do spawntask {
-                port.take().recv();
-                client.take()(UnixStream::connect(&path2).unwrap());
+                port.recv();
+                client(UnixStream::connect(&path2).unwrap());
             }
         }
     }
@@ -260,12 +254,10 @@ mod tests {
             let path1 = next_test_unix();
             let path2 = path1.clone();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = UnixListener::bind(&path1).listen();
-                chan.take().send(());
+                chan.send(());
                 times.times(|| {
                     let mut client = acceptor.accept();
                     let mut buf = [0];
@@ -275,7 +267,7 @@ mod tests {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 times.times(|| {
                     let mut stream = UnixStream::connect(&path2);
                     stream.write([100]);