Properly get server-process handle in all situations that need it

This fixes big-data sending to a different process when there are
no handles or shmems to send -- we wouldn't actually get the
other process handle at the start, so would end up dup'ing the
big-data receiver handle to INVALID_HANDLE_VALUE, which is
a pseudohandle for the current process.  The remote would then
try to read and get an INVALID_HANDLE error.

src/platform/windows/mod.rs

@@ -956,33 +956,34 @@ impl OsIpcSender {
         // to.
         assert!(data.len() < INVALID_HEADER_DATA_SIZE as usize);
 
-        let server_process_handle =
-            if ports.len() > 0 || shared_memory_regions.len() > 0 {
-                try!(self.get_pipe_server_process_handle())
-            } else {
-                WinHandle::invalid()
-            };
+        let mut server_process_handle_opt: Option<WinHandle> = None;
+        let mut server_process_handle = || {
+            if server_process_handle_opt.is_none() {
+                server_process_handle_opt = Some(self.get_pipe_server_process_handle().unwrap());
+            }
+            **server_process_handle_opt.as_ref().unwrap()
+        };
 
         let mut oob = OsIpcOutOfBandMessage::new();
 
         for ref shmem in shared_memory_regions {
             // shmem.handle, shmem.length
-            let remote_handle = try!(dup_handle_to_process(*shmem.handle, *server_process_handle));
+            let remote_handle = try!(dup_handle_to_process(*shmem.handle, server_process_handle()));
             oob.add_shmem(remote_handle, shmem.length);
         }
 
         for port in ports {
             match port {
                 OsIpcChannel::Sender(mut s) => {
-                    let raw_remote_handle = try!(move_handle_to_process(s.handle.take(), *server_process_handle));
+                    let raw_remote_handle = try!(move_handle_to_process(s.handle.take(), server_process_handle()));
                     oob.add_sender(raw_remote_handle);
                 },
                 OsIpcChannel::Receiver(mut r) => {
                     if try!(r.prepare_for_transfer()) == false {
                         panic!("Sending receiver with outstanding partial read buffer, noooooo!  What should even happen?");
                     }
 
-                    let raw_remote_handle = try!(move_handle_to_process(r.handle.take(), *server_process_handle));
+                    let raw_remote_handle = try!(move_handle_to_process(r.handle.take(), server_process_handle()));
                     oob.add_receiver(raw_remote_handle);
                 },
             }
@@ -996,7 +997,7 @@ impl OsIpcSender {
             big_data_sender = Some(try!(receiver.sender()));
 
             // Put the receiver in the OOB data
-            let raw_receiver_handle = try!(move_handle_to_process(receiver.handle.take(), *server_process_handle));
+            let raw_receiver_handle = try!(move_handle_to_process(receiver.handle.take(), server_process_handle()));
             oob.set_big_data_receiver_handle(raw_receiver_handle);
         }