libstd: Remove some cells involved in

`deschedule_running_task_and_then`.

2 files changed, 12 insertions, 18 deletions

diff --git a/src/libstd/rt/tube.rs b/src/libstd/rt/tube.rs
index 15d8c7f9aac..5e867bcdfba 100644
--- a/src/libstd/rt/tube.rs
+++ b/src/libstd/rt/tube.rs
@@ -88,7 +88,6 @@ impl<T> Clone for Tube<T> {
 
 #[cfg(test)]
 mod test {
-    use cell::Cell;
     use rt::test::*;
     use rt::rtio::EventLoop;
     use rt::sched::Scheduler;
@@ -100,11 +99,10 @@ mod test {
     fn simple_test() {
         do run_in_newsched_task {
             let mut tube: Tube<int> = Tube::new();
-            let tube_clone = tube.clone();
-            let tube_clone_cell = Cell::new(tube_clone);
+            let mut tube_clone = Some(tube.clone());
             let sched: ~Scheduler = Local::take();
             sched.deschedule_running_task_and_then(|sched, task| {
-                let mut tube_clone = tube_clone_cell.take();
+                let mut tube_clone = tube_clone.take_unwrap();
                 tube_clone.send(1);
                 sched.enqueue_blocked_task(task);
             });
@@ -117,11 +115,10 @@ mod test {
     fn blocking_test() {
         do run_in_newsched_task {
             let mut tube: Tube<int> = Tube::new();
-            let tube_clone = tube.clone();
-            let tube_clone = Cell::new(tube_clone);
+            let mut tube_clone = Some(tube.clone());
             let sched: ~Scheduler = Local::take();
             sched.deschedule_running_task_and_then(|sched, task| {
-                let tube_clone = tube_clone.take();
+                let tube_clone = tube_clone.take_unwrap();
                 do sched.event_loop.callback {
                     let mut tube_clone = tube_clone;
                     // The task should be blocked on this now and
@@ -141,11 +138,10 @@ mod test {
 
         do run_in_newsched_task {
             let mut tube: Tube<int> = Tube::new();
-            let tube_clone = tube.clone();
-            let tube_clone = Cell::new(tube_clone);
+            let mut tube_clone = Some(tube.clone());
             let sched: ~Scheduler = Local::take();
             sched.deschedule_running_task_and_then(|sched, task| {
-                callback_send(tube_clone.take(), 0);
+                callback_send(tube_clone.take_unwrap(), 0);
 
                 fn callback_send(tube: Tube<int>, i: int) {
                     if i == 100 {
diff --git a/src/libstd/select.rs b/src/libstd/select.rs
index 43f1c3c5296..4f78ade3f08 100644
--- a/src/libstd/select.rs
+++ b/src/libstd/select.rs
@@ -60,7 +60,7 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint {
     let c = Cell::new(c);
 
     (|| {
-        let c = Cell::new(c.take());
+        let mut c = Some(c.take());
         let sched: ~Scheduler = Local::take();
         sched.deschedule_running_task_and_then(|sched, task| {
             let task_handles = task.make_selectable(ports.len());
@@ -74,8 +74,10 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint {
                 }
             }
 
-            let c = Cell::new(c.take());
-            do sched.event_loop.callback { c.take().send_deferred(()) }
+            let c = c.take_unwrap();
+            do sched.event_loop.callback {
+                c.send_deferred(())
+            }
         })
     }).finally(|| {
         // Unkillable is necessary not because getting killed is dangerous here,
@@ -133,7 +135,6 @@ mod test {
     use vec::*;
     use comm::GenericChan;
     use task;
-    use cell::Cell;
     use iter::{Iterator, range};
 
     #[test] #[should_fail]
@@ -246,9 +247,7 @@ mod test {
             let (p3,c3) = oneshot();
             let (p4,c4) = oneshot();
 
-            let x = Cell::new((c2, p3, c4));
             do task::spawn {
-                let (c2, p3, c4) = x.take();
                 p3.recv();   // handshake parent
                 c4.send(()); // normal receive
                 task::deschedule();
@@ -284,10 +283,9 @@ mod test {
                             let (p,c) = oneshot();
                             ports.push(p);
                             if send_on_chans.contains(&i) {
-                                let c = Cell::new(c);
                                 do spawntask_random {
                                     task::deschedule();
-                                    c.take().send(());
+                                    c.send(());
                                 }
                             }
                         }