---

yaml
---
r: 91607
b: refs/heads/auto
c: 1bdaea8
h: refs/heads/master
i:
  91605: e5b5cdb
  91603: 2349318
  91599: 53b185b
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: f9abd998d6a5368c54162deb0bf187e94e31dc27
+refs/heads/auto: 1bdaea827ed957ce404fffee27923e9606584ce0
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustuv/net.rs

@@ -313,7 +313,7 @@ impl rtio::RtioTcpStream for TcpWatcher {
 impl Drop for TcpWatcher {
     fn drop(&mut self) {
         let _m = self.fire_missiles();
-        self.stream.close(true);
+        self.stream.close();
     }
 }
 

branches/auto/src/librustuv/pipe.rs

@@ -136,7 +136,7 @@ impl HomingIO for PipeWatcher {
 impl Drop for PipeWatcher {
     fn drop(&mut self) {
         let _m = self.fire_missiles();
-        self.stream.close(true); // close synchronously
+        self.stream.close();
     }
 }
 

branches/auto/src/librustuv/stream.rs

@@ -10,7 +10,6 @@
 
 use std::cast;
 use std::libc::{c_int, size_t, ssize_t, c_void};
-use std::ptr;
 use std::rt::BlockedTask;
 use std::rt::local::Local;
 use std::rt::sched::Scheduler;
@@ -124,35 +123,23 @@ impl StreamWatcher {
 
     // This will deallocate an internally used memory, along with closing the
     // handle (and freeing it).
-    //
-    // The `synchronous` flag dictates whether this handle is closed
-    // synchronously (the task is blocked) or asynchronously (the task is not
-    // block, but the handle is still deallocated).
-    pub fn close(&mut self, synchronous: bool) {
-        if synchronous {
-            let mut closing_task = None;
-            unsafe {
-                uvll::set_data_for_uv_handle(self.handle, &closing_task);
-            }
+    pub fn close(&mut self) {
+        let mut closing_task = None;
+        unsafe {
+            uvll::set_data_for_uv_handle(self.handle, &closing_task);
+        }
 
-            // Wait for this stream to close because it possibly represents a remote
-            // connection which may have consequences if we close asynchronously.
-            let sched: ~Scheduler = Local::take();
-            do sched.deschedule_running_task_and_then |_, task| {
-                closing_task = Some(task);
-                unsafe { uvll::uv_close(self.handle, close_cb) }
-            }
-        } else {
-            unsafe {
-                uvll::set_data_for_uv_handle(self.handle, ptr::null::<u8>());
-                uvll::uv_close(self.handle, close_cb)
-            }
+        // Wait for this stream to close because it possibly represents a remote
+        // connection which may have consequences if we close asynchronously.
+        let sched: ~Scheduler = Local::take();
+        do sched.deschedule_running_task_and_then |_, task| {
+            closing_task = Some(task);
+            unsafe { uvll::uv_close(self.handle, close_cb) }
         }
 
         extern fn close_cb(handle: *uvll::uv_handle_t) {
             let data: *c_void = unsafe { uvll::get_data_for_uv_handle(handle) };
             unsafe { uvll::free_handle(handle) }
-            if data.is_null() { return }
 
             let closing_task: &mut Option<BlockedTask> = unsafe {
                 cast::transmute(data)

branches/auto/src/librustuv/tty.rs

@@ -101,13 +101,8 @@ impl HomingIO for TtyWatcher {
 }
 
 impl Drop for TtyWatcher {
-    // TTY handles are used for the logger in a task, so this destructor is run
-    // when a task is destroyed. When a task is being destroyed, a local
-    // scheduler isn't available, so we can't do the normal "take the scheduler
-    // and resume once close is done". Instead close operations on a TTY are
-    // asynchronous.
     fn drop(&mut self) {
         let _m = self.fire_missiles();
-        self.stream.close(false);
+        self.stream.close();
     }
 }