Add Process.runSync for running processe synchronously.

runtime/bin/process_patch.dart

 // Copyright (c) 2013, 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.
 
 patch class _WindowsCodePageDecoder {
   /* patch */ static String _decodeBytes(List<int> bytes)
       native "SystemEncodingToString";
 }
 
 
@@ skipping 31 matching lines @@
        Encoding stderrEncoding: Encoding.SYSTEM}) {
     return _runNonInteractiveProcess(executable,
                                      arguments,
                                      workingDirectory,
                                      environment,
                                      includeParentEnvironment,
                                      runInShell,
                                      stdoutEncoding,
                                      stderrEncoding);
   }
+
+  /* patch */ static ProcessResult runSync(
+      String executable,
+      List<String> arguments,
+      {String workingDirectory,
+       Map<String, String> environment,
+       bool includeParentEnvironment: true,
+       bool runInShell: false,
+       Encoding stdoutEncoding: Encoding.SYSTEM,
+       Encoding stderrEncoding: Encoding.SYSTEM}) {
+    return _runNonInteractiveProcessSync(executable,
+                                         arguments,
+                                         workingDirectory,
+                                         environment,
+                                         includeParentEnvironment,
+                                         runInShell,
+                                         stdoutEncoding,
+                                         stderrEncoding);
+  }
 }
 
 
 patch class _ProcessUtils {
   /* patch */ static void _exit(int status) native "Process_Exit";
   /* patch */ static void _setExitCode(int status)
       native "Process_SetExitCode";
   /* patch */ static void _sleep(int millis) native "Process_Sleep";
   /* patch */ static int _pid(Process process) native "Process_Pid";
 }
@@ skipping 209 matching lines @@
         if (exitDataRead == EXIT_DATA_SIZE) {
           handleExit();
         }
       });
 
       completer.complete(this);
     });
     return completer.future;
   }
 
+  ProcessResult _runAndWait(Encoding stdoutEncoding,
+                            Encoding stderrEncoding) {
+    var status = new _ProcessStartStatus();
+    bool success = _startNative(_path,
+                                _arguments,
+                                _workingDirectory,
+                                _environment,
+                                _stdin._sink._nativeSocket,
+                                _stdout._stream._nativeSocket,
+                                _stderr._stream._nativeSocket,
+                                _exitHandler._nativeSocket,
+                                status);
+    if (!success) {
+      throw new ProcessException(_path,
+                                 _arguments,
+                                 status._errorMessage,
+                                 status._errorCode);
+    }
+
+    var result = _wait(
+        _stdin._sink._nativeSocket,
+        _stdout._stream._nativeSocket,
+        _stderr._stream._nativeSocket,
+        _exitHandler._nativeSocket);
+
+    getOutput(output, encoding) {
+      if (stderrEncoding == null) return output;
+      return _decodeString(output, encoding);
+    }
+
+    return new _ProcessResult(
+        result[0],
+        result[1],
+        getOutput(result[2], stdoutEncoding),
+        getOutput(result[3], stderrEncoding));
+  }
+
   bool _startNative(String path,
                     List<String> arguments,
                     String workingDirectory,
                     List<String> environment,
                     _NativeSocket stdin,
                     _NativeSocket stdout,
                     _NativeSocket stderr,
                     _NativeSocket exitHandler,
                     _ProcessStartStatus status) native "Process_Start";
 
+  _wait(_NativeSocket stdin,
+        _NativeSocket stdout,
+        _NativeSocket stderr,
+        _NativeSocket exitHandler) native "Process_Wait";
+
   Stream<List<int>> get stdout {
     return _stdout;
   }
 
   Stream<List<int>> get stderr {
     return _stderr;
   }
 
   IOSink get stdin {
     return _stdin;
@@ skipping 75 matching lines @@
 
     Future stdout = foldStream(p.stdout, stdoutEncoding);
     Future stderr = foldStream(p.stderr, stderrEncoding);
 
     return Future.wait([p.exitCode, stdout, stderr]).then((result) {
       return new _ProcessResult(pid, result[0], result[1], result[2]);
     });
   });
 }
 
+ProcessResult _runNonInteractiveProcessSync(
+      String executable,
+      List<String> arguments,
+      String workingDirectory,
+      Map<String, String> environment,
+      bool includeParentEnvironment,
+      bool runInShell,
+      Encoding stdoutEncoding,
+      Encoding stderrEncoding) {
+  var process = new _ProcessImpl(executable,
+                                 arguments,
+                                 workingDirectory,
+                                 environment,
+                                 includeParentEnvironment,
+                                 runInShell);
+  return process._runAndWait(stdoutEncoding, stderrEncoding);
+}
+
 
 class _ProcessResult implements ProcessResult {
   const _ProcessResult(int this.pid,
                        int this.exitCode,
                        this.stdout,
                        this.stderr);
 
   final int pid;
   final int exitCode;
   final stdout;
   final stderr;
 }