---

yaml
---
r: 146157
b: refs/heads/try2
c: 32b07c6
h: refs/heads/master
i:
  146155: 06f4f45
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: c6fa4e277f5eb873e979d8ac1ae7a4c3ccb1e9cc
+refs/heads/try2: 32b07c6a40bd7e1874244096f413096a6e059a29
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/rt/io/mod.rs

@@ -261,7 +261,6 @@ pub use self::net::tcp::TcpListener;
 pub use self::net::tcp::TcpStream;
 pub use self::net::udp::UdpStream;
 pub use self::pipe::PipeStream;
-pub use self::pipe::UnboundPipeStream;
 pub use self::process::Process;
 
 // Some extension traits that all Readers and Writers get.

branches/try2/src/libstd/rt/io/pipe.rs

@@ -16,35 +16,13 @@
 use prelude::*;
 use super::{Reader, Writer};
 use rt::io::{io_error, read_error, EndOfFile};
-use rt::local::Local;
-use rt::rtio::{RtioPipe, RtioPipeObject, IoFactoryObject, IoFactory};
-use rt::rtio::RtioUnboundPipeObject;
+use rt::rtio::{RtioPipe, RtioPipeObject};
 
 pub struct PipeStream {
     priv obj: ~RtioPipeObject
 }
 
-// This should not be a newtype, but rt::uv::process::set_stdio needs to reach
-// into the internals of this :(
-pub struct UnboundPipeStream(~RtioUnboundPipeObject);
-
 impl PipeStream {
-    /// Creates a new pipe initialized, but not bound to any particular
-    /// source/destination
-    pub fn new() -> Option<UnboundPipeStream> {
-        let pipe = unsafe {
-            let io: *mut IoFactoryObject = Local::unsafe_borrow();
-            (*io).pipe_init(false)
-        };
-        match pipe {
-            Ok(p) => Some(UnboundPipeStream(p)),
-            Err(ioerr) => {
-                io_error::cond.raise(ioerr);
-                None
-            }
-        }
-    }
-
     pub fn new_bound(inner: ~RtioPipeObject) -> PipeStream {
         PipeStream { obj: inner }
     }

branches/try2/src/libstd/rt/io/process.rs

@@ -70,15 +70,13 @@ pub enum StdioContainer {
     /// specified for.
     InheritFd(libc::c_int),
 
-    /// Creates a pipe for the specified file descriptor which will be directed
-    /// into the previously-initialized pipe passed in.
+    /// Creates a pipe for the specified file descriptor which will be created
+    /// when the process is spawned.
     ///
     /// The first boolean argument is whether the pipe is readable, and the
     /// second is whether it is writable. These properties are from the view of
     /// the *child* process, not the parent process.
-    CreatePipe(io::UnboundPipeStream,
-               bool /* readable */,
-               bool /* writable */),
+    CreatePipe(bool /* readable */, bool /* writable */),
 }
 
 impl Process {

branches/try2/src/libstd/rt/rtio.rs

@@ -35,7 +35,6 @@ pub type RtioUdpSocketObject = uvio::UvUdpSocket;
 pub type RtioTimerObject = uvio::UvTimer;
 pub type PausibleIdleCallback = uvio::UvPausibleIdleCallback;
 pub type RtioPipeObject = uvio::UvPipeStream;
-pub type RtioUnboundPipeObject = uvio::UvUnboundPipe;
 pub type RtioProcessObject = uvio::UvProcess;
 pub type RtioUnixListenerObject = uvio::UvUnixListener;
 pub type RtioUnixAcceptorObject = uvio::UvUnixAcceptor;
@@ -88,7 +87,6 @@ pub trait IoFactory {
     fn fs_rmdir<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
     fn fs_readdir<P: PathLike>(&mut self, path: &P, flags: c_int) ->
         Result<~[Path], IoError>;
-    fn pipe_init(&mut self, ipc: bool) -> Result<~RtioUnboundPipeObject, IoError>;
     fn spawn(&mut self, config: ProcessConfig)
             -> Result<(~RtioProcessObject, ~[Option<~RtioPipeObject>]), IoError>;
 

branches/try2/src/libstd/rt/uv/process.rs

@@ -17,7 +17,7 @@ use vec;
 
 use rt::io::process::*;
 use rt::uv;
-use rt::uv::uvio::UvPipeStream;
+use rt::uv::uvio::{UvPipeStream, UvUnboundPipe};
 use rt::uv::uvll;
 
 /// A process wraps the handle of the underlying uv_process_t.
@@ -68,7 +68,8 @@ impl Process {
         unsafe {
             vec::raw::set_len(&mut stdio, io.len());
             for (slot, other) in stdio.iter().zip(io.move_iter()) {
-                let io = set_stdio(slot as *uvll::uv_stdio_container_t, other);
+                let io = set_stdio(slot as *uvll::uv_stdio_container_t, other,
+                                   loop_);
                 ret_io.push(io);
             }
         }
@@ -144,7 +145,8 @@ impl Process {
 }
 
 unsafe fn set_stdio(dst: *uvll::uv_stdio_container_t,
-                    io: StdioContainer) -> Option<~UvPipeStream> {
+                    io: StdioContainer,
+                    loop_: &uv::Loop) -> Option<~UvPipeStream> {
     match io {
         Ignored => {
             uvll::set_stdio_container_flags(dst, uvll::STDIO_IGNORE);
@@ -155,18 +157,19 @@ unsafe fn set_stdio(dst: *uvll::uv_stdio_container_t,
             uvll::set_stdio_container_fd(dst, fd);
             None
         }
-        CreatePipe(pipe, readable, writable) => {
+        CreatePipe(readable, writable) => {
             let mut flags = uvll::STDIO_CREATE_PIPE as libc::c_int;
             if readable {
                 flags |= uvll::STDIO_READABLE_PIPE as libc::c_int;
             }
             if writable {
                 flags |= uvll::STDIO_WRITABLE_PIPE as libc::c_int;
             }
+            let pipe = UvUnboundPipe::new_fresh(loop_);
             let handle = pipe.pipe.as_stream().native_handle();
             uvll::set_stdio_container_flags(dst, flags);
             uvll::set_stdio_container_stream(dst, handle);
-            Some(~UvPipeStream::new(**pipe))
+            Some(~UvPipeStream::new(pipe))
         }
     }
 }

branches/try2/src/libstd/rt/uv/uvio.rs

@@ -749,11 +749,6 @@ impl IoFactory for UvIoFactory {
         return result_cell.take();
     }
 
-    fn pipe_init(&mut self, ipc: bool) -> Result<~RtioUnboundPipeObject, IoError> {
-        let home = get_handle_to_current_scheduler!();
-        Ok(~UvUnboundPipe::new(Pipe::new(self.uv_loop(), ipc), home))
-    }
-
     fn spawn(&mut self, config: ProcessConfig)
             -> Result<(~RtioProcessObject, ~[Option<~RtioPipeObject>]), IoError>
     {
@@ -1069,9 +1064,19 @@ pub struct UvUnboundPipe {
 }
 
 impl UvUnboundPipe {
+    /// Takes ownership of an unbound pipe along with the scheduler that it is
+    /// homed on.
     fn new(pipe: Pipe, home: SchedHandle) -> UvUnboundPipe {
         UvUnboundPipe { pipe: pipe, home: home }
     }
+
+    /// Creates a fresh new unbound pipe on the specified I/O loop
+    pub fn new_fresh(loop_: &Loop) -> UvUnboundPipe {
+        UvUnboundPipe {
+            pipe: Pipe::new(loop_, false),
+            home: get_handle_to_current_scheduler!(),
+        }
+    }
 }
 
 impl HomingIO for UvUnboundPipe {

branches/try2/src/test/run-pass/rtio-processes.rs

@@ -25,7 +25,6 @@
 
 use std::rt::io::process::{Process, ProcessConfig, CreatePipe, Ignored};
 use std::rt::io::{Reader, Writer};
-use std::rt::io::pipe::PipeStream;
 use std::str;
 
 #[test]
@@ -105,8 +104,7 @@ fn run_output(args: ProcessConfig) -> ~str {
 #[test]
 #[cfg(unix, not(target_os="android"))]
 fn stdout_works() {
-    let pipe = PipeStream::new().unwrap();
-    let io = ~[Ignored, CreatePipe(pipe, false, true)];
+    let io = ~[Ignored, CreatePipe(false, true)];
     let args = ProcessConfig {
         program: "/bin/sh",
         args: [~"-c", ~"echo foobar"],
@@ -120,8 +118,7 @@ fn stdout_works() {
 #[test]
 #[cfg(unix, not(target_os="android"))]
 fn set_cwd_works() {
-    let pipe = PipeStream::new().unwrap();
-    let io = ~[Ignored, CreatePipe(pipe, false, true)];
+    let io = ~[Ignored, CreatePipe(false, true)];
     let cwd = Some("/");
     let args = ProcessConfig {
         program: "/bin/sh",
@@ -136,10 +133,8 @@ fn set_cwd_works() {
 #[test]
 #[cfg(unix, not(target_os="android"))]
 fn stdin_works() {
-    let input = PipeStream::new().unwrap();
-    let output = PipeStream::new().unwrap();
-    let io = ~[CreatePipe(input, true, false),
-               CreatePipe(output, false, true)];
+    let io = ~[CreatePipe(true, false),
+               CreatePipe(false, true)];
     let args = ProcessConfig {
         program: "/bin/sh",
         args: [~"-c", ~"read line; echo $line"],