Include parent environment by default, add option to not, for Process.

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";
 }
 
 
 patch class _WindowsCodePageEncoder {
   /* patch */ static List<int> _encodeString(String string)
       native "StringToSystemEncoding";
 }
 
 
 patch class Process {
   /* patch */ static Future<Process> start(
       String executable,
       List<String> arguments,
       {String workingDirectory,
        Map<String, String> environment,
-       bool runInShell}) {
+       bool includeParentEnvironment: true,
+       bool runInShell: false}) {
     _ProcessImpl process = new _ProcessImpl(executable,
                                             arguments,
                                             workingDirectory,
                                             environment,
+                                            includeParentEnvironment,
                                             runInShell);
     return process._start();
   }
 
   /* patch */ static Future<ProcessResult> run(
       String executable,
       List<String> arguments,
       {String workingDirectory,
        Map<String, String> environment,
-       bool runInShell,
+       bool includeParentEnvironment: true,
+       bool runInShell: false,
        Encoding stdoutEncoding: Encoding.SYSTEM,
        Encoding stderrEncoding: Encoding.SYSTEM}) {
     return _runNonInteractiveProcess(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";
 }
 
 
 class _ProcessStartStatus {
   int _errorCode;  // Set to OS error code if process start failed.
   String _errorMessage;  // Set to OS error message if process start failed.
 }
 
 
 class _ProcessImpl extends NativeFieldWrapperClass1 implements Process {
   _ProcessImpl(String path,
                List<String> arguments,
                String this._workingDirectory,
                Map<String, String> environment,
+               bool includeParentEnvironment,
                bool runInShell) {
     runInShell = identical(runInShell, true);
     if (runInShell) {
       arguments = _getShellArguments(path, arguments);
       path = _getShellCommand();
     }
 
     if (path is !String) {
       throw new ArgumentError("Path is not a String: $path");
     }
@@ skipping 13 matching lines @@
       if (Platform.operatingSystem == 'windows') {
         _arguments[i] = _windowsArgumentEscape(_arguments[i]);
       }
     }
 
     if (_workingDirectory != null && _workingDirectory is !String) {
       throw new ArgumentError(
           "WorkingDirectory is not a String: $_workingDirectory");
     }
 
-    if (environment != null) {
-      var env = environment;
-      if (env is !Map) {
-        throw new ArgumentError("Environment is not a map: $env");
+    _environment = [];
+    if (environment == null) {
+      environment = {};
+    }
+    if (environment is !Map) {
+      throw new ArgumentError("Environment is not a map: $environment");
+    }
+    if (identical(true, includeParentEnvironment)) {
+      environment = Platform.environment..addAll(environment);
+    }
+    environment.forEach((key, value) {
+      if (key is !String || value is !String) {
+        throw new ArgumentError(
+            "Environment key or value is not a string: ($key, $value)");
       }
-      _environment = [];
-      env.forEach((key, value) {
-        if (key is !String || value is !String) {
-          throw new ArgumentError(
-              "Environment key or value is not a string: ($key, $value)");
-        }
-        _environment.add('$key=$value');
-      });
-    }
+      _environment.add('$key=$value');
+    });
 
     // stdin going to process.
     _stdin = new _StdSink(new _Socket._writePipe());
     // stdout coming from process.
     _stdout = new _StdStream(new _Socket._readPipe());
     // stderr coming from process.
     _stderr = new _StdStream(new _Socket._readPipe());
     _exitHandler = new _Socket._readPipe();
     _ended = false;
     _started = false;
@@ skipping 196 matching lines @@
 
 
 // _NonInteractiveProcess is a wrapper around an interactive process
 // that buffers output so it can be delivered when the process exits.
 // _NonInteractiveProcess is used to implement the Process.run
 // method.
 Future<ProcessResult> _runNonInteractiveProcess(String path,
                                                 List<String> arguments,
                                                 String workingDirectory,
                                                 Map<String, String> environment,
+                                                bool includeParentEnvironment,
                                                 bool runInShell,
                                                 Encoding stdoutEncoding,
                                                 Encoding stderrEncoding) {
   // Start the underlying process.
   return Process.start(path,
                        arguments,
                        workingDirectory: workingDirectory,
                        environment: environment,
+                       includeParentEnvironment: includeParentEnvironment,
                        runInShell: runInShell).then((Process p) {
     int pid = p.pid;
 
     // Make sure the process stdin is closed.
     p.stdin.close();
 
     // Setup stdout and stderr handling.
     Future foldStream(Stream<List<int>> stream, Encoding encoding) {
       if (encoding == null) {
         return stream
@@ skipping 31 matching lines @@
   const _ProcessResult(int this.pid,
                        int this.exitCode,
                        this.stdout,
                        this.stderr);
 
   final int pid;
   final int exitCode;
   final stdout;
   final stderr;
 }