Add support for starting a detached process

tests/standalone/io/process_detached_test.dart

+// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+//
+// Process test program to test detached processes.
+
+import 'dart:async';
+import 'dart:io';
+
+import "package:async_helper/async_helper.dart";
+import "package:expect/expect.dart";
+
+import "process_test_util.dart";
+
+void test() {
+  asyncStart();
+  var script =
+      Platform.script.resolve('process_detached_script.dart').toFilePath();
+  var future = Process.start(Platform.executable, [script], detach: true);
+  future.then((process) {
+    print(process.pid);
+    Expect.isNotNull(process.pid);
+    Expect.isTrue(process.pid is int);
+    Expect.isNull(process.exitCode);
+    Expect.isNull(process.stderr);
+    Expect.isNull(process.stdin);
+    Expect.isNull(process.stdout);
+    Expect.isTrue(process.kill());
+  }).whenComplete(() {
+    asyncEnd();
+  });

[kustermann, 2015/01/22 09:33:02]

Regarding this test: Assuming we would actually not detach the process but
rather just make stderr/stdin/stdout/exitCode null, how would this test catch
this? I.e. how do we test for the actual detaching?

Maybe we would need to put a process in the middle which will be killed and it's
parent could check for the existence of the grand child & kill it then.
Something like that.

[Søren Gjesse, 2015/01/22 11:47:25]

Sounds like a good idea. I will think of something in a separate CL. That would
need support for killing a specific PID as well.

+}
+
+void testFailure() {
+  asyncStart();
+  Directory.systemTemp.createTemp('dart_detached_process').then((temp) {
+    var future = Process.start(temp.path, ['a', 'b'], detach: true);
+    future.then((process) {
+      Expect.fail('Starting process from invalid executable succeeded');
+    }, onError: (e) {
+      Expect.isTrue(e is ProcessException);
+    }).whenComplete(() {
+      temp.deleteSync();
+      asyncEnd();
+    });
+  });
+}
+
+main() {
+  test();
+  testFailure();
+}