Fix several Windows issues.

lib/src/executable.dart

 // Copyright (c) 2014, 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.
 
 library pub.executable;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as p;
 import 'package:stack_trace/stack_trace.dart';
 
 import 'barback/asset_environment.dart';
+import 'cr_lf_remover.dart';
 import 'entrypoint.dart';
 import 'exit_codes.dart' as exit_codes;
 import 'io.dart';
 import 'log.dart' as log;
 import 'utils.dart';
 
 /// All signals that can be caught by a Dart process.
 ///
 /// This intentionally omits SIGINT. SIGINT usually comes from a user pressing
 /// Control+C on the terminal, and the terminal automatically passes the signal
@@ skipping 95 matching lines @@
 
   vmArgs.add(executableUrl.toString());
   vmArgs.addAll(args);
 
   var process = await Process.start(Platform.executable, vmArgs);
 
   _forwardSignals(process);
 
   // Note: we're not using process.std___.pipe(std___) here because
   // that prevents pub from also writing to the output streams.
-  process.stderr.listen(stderr.add);
-  process.stdout.listen(stdout.add);
+  _forwardOutput(process.stderr, stderr);
+  _forwardOutput(process.stdout, stdout);
   stdin.listen(process.stdin.add);
 
   return process.exitCode;
 }
 
 /// Returns the URL the VM should use to load the executable at [path].
 ///
 /// [path] must be relative to the root of [package]. If [path] doesn't exist,
 /// returns `null`.
 Future<Uri> _executableUrl(Entrypoint entrypoint, String package, String path,
@@ skipping 82 matching lines @@
     stdin2 = pair.last;
   }
 
   runProcess(input) async {
     var process = await Process.start(Platform.executable, vmArgs);
 
     _forwardSignals(process);
 
     // Note: we're not using process.std___.pipe(std___) here because
     // that prevents pub from also writing to the output streams.
-    process.stderr.listen(stderr.add);
-    process.stdout.listen(stdout.add);
+    _forwardOutput(process.stderr, stderr);
+    _forwardOutput(process.stdout, stdout);
     input.listen(process.stdin.add);
 
     return process.exitCode;
   }
 
   var exitCode = await runProcess(stdin1);
   if (recompile == null || exitCode != 253) return exitCode;
 
   // Exit code 253 indicates that the snapshot version was out-of-date. If we
   // can recompile, do so.
   await recompile();
   return runProcess(stdin2);
 }
 
 /// Forwards all catchable signals to [process].
 void _forwardSignals(Process process) {
   // See [_catchableSignals].
   ProcessSignal.SIGINT.watch().listen(
       (_) => log.fine("Ignoring SIGINT in pub."));
 
   for (var signal in _catchableSignals) {
     signal.watch().listen((_) {
       log.fine("Forwarding $signal to running process.");
       process.kill(signal);
     });
   }
 }
 
+/// Forwards output from a Process's output stream to the corresponding stream
+/// for pub.
+///
+/// On Windows, this replaces any CR LF sequences in the process's output with
+/// just LF to work around sdk#19334.
+void _forwardOutput(Stream<List<int>> stream, Sink<List<int>> sink) {
+  if (Platform.isWindows) {
+    log.fine("filtering out CR LF");
+    stream = const CRLFRemover().bind(stream);
+  }
+  stream.listen(sink.add);
+}
+
 /// Runs the executable snapshot at [snapshotPath].
 Future<int> _runCachedExecutable(Entrypoint entrypoint, String snapshotPath,
     List<String> args) {
   return runSnapshot(snapshotPath, args, checked: true, recompile: () {
     log.fine("Precompiled executable is out of date.");
     return entrypoint.precompileExecutables();
   });
 }