Code cleanup (mostly io lib and some http lib).

sdk/lib/io/process.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.
 
 part of dart.io;
 
 // TODO(ager): The only reason for this class is that we
 // cannot patch a top-level at this point.
 class _ProcessUtils {
   external static void _exit(int status);
@@ skipping 72 matching lines @@
  * Returns the PID of the current process.
  */
 int get pid => _ProcessUtils._pid(null);
 
 /**
  * [Process] is used to start new processes using the static
  * [start] and [run] methods.
  */
 abstract class Process {
   /**
+   * Returns a [:Future:] which completes with the exit code of the process
+   * when the process completes.
+   *
+   * The handling of exit codes is platform specific.
+   *
+   * On Linux and Mac a normal exit code will be a positive value in
+   * the range [0..255]. If the process was terminated due to a signal
+   * the exit code will be a negative value in the range [-255..0[,
+   * where the absolute value of the exit code is the signal
+   * number. For example, if a process crashes due to a segmentation
+   * violation the exit code will be -11, as the signal SIGSEGV has the
+   * number 11.
+   *
+   * On Windows a process can report any 32-bit value as an exit
+   * code. When returning the exit code this exit code is turned into
+   * a signed value. Some special values are used to report
+   * termination due to some system event. E.g. if a process crashes
+   * due to an access violation the 32-bit exit code is `0xc0000005`,
+   * which will be returned as the negative number `-1073741819`. To
+   * get the original 32-bit value use `(0x100000000 + exitCode) &
+   * 0xffffffff`.
+   */
+  Future<int> exitCode;
+
+  /**
    * Starts a process running the [executable] with the specified
    * [arguments]. Returns a [:Future<Process>:] that completes with a
    * Process instance when the process has been successfully
    * started. That [Process] object can be used to interact with the
    * process. If the process cannot be started the returned [Future]
    * completes with an exception.
    *
    * Use [workingDirectory] to set the working directory for the process. Note
    * that the change of directory occurs before executing the process on some
    * platforms, which may have impact when using relative paths for the
@@ skipping 119 matching lines @@
    * Returns the standard input stream of the process as an [IOSink].
    */
   IOSink get stdin;
 
   /**
    * Returns the process id of the process.
    */
   int get pid;
 
   /**
-   * Returns a [:Future:] which completes with the exit code of the process
-   * when the process completes.
-   *
-   * The handling of exit codes is platform specific.
-   *
-   * On Linux and Mac a normal exit code will be a positive value in
-   * the range [0..255]. If the process was terminated due to a signal
-   * the exit code will be a negative value in the range [-255..0[,
-   * where the absolute value of the exit code is the signal
-   * number. For example, if a process crashes due to a segmentation
-   * violation the exit code will be -11, as the signal SIGSEGV has the
-   * number 11.
-   *
-   * On Windows a process can report any 32-bit value as an exit
-   * code. When returning the exit code this exit code is turned into
-   * a signed value. Some special values are used to report
-   * termination due to some system event. E.g. if a process crashes
-   * due to an access violation the 32-bit exit code is `0xc0000005`,
-   * which will be returned as the negative number `-1073741819`. To
-   * get the original 32-bit value use `(0x100000000 + exitCode) &
-   * 0xffffffff`.
-   */
-  Future<int> exitCode;
-
-  /**
    * On Windows, [kill] kills the process, ignoring the [signal]
    * flag. On Posix systems, [kill] sends [signal] to the
    * process. Depending on the signal giving, it'll have different
    * meanings. When the process terminates as a result of calling
    * [kill] [onExit] is called.
    *
    * Returns [:true:] if the process is successfully killed (the
    * signal is successfully sent). Returns [:false:] if the process
    * could not be killed (the signal could not be sent). Usually,
    * a [:false:] return value from kill means that the process is
@@ skipping 82 matching lines @@
   String toString() => _name;
 
   Stream<ProcessSignal> watch() => _ProcessUtils._watchSignal(this);
 }
 
 
 class SignalException implements IOException {
   final String message;
   final osError;
 
-  const SignalException(String this.message, [this.osError = null]);
+  const SignalException(this.message, [this.osError = null]);
 
   String toString() {
     var msg = "";
     if (osError != null) {
       msg = ", osError: $osError";
     }
     return "SignalException: $message$msg";
   }
 }
 
 
 class ProcessException implements IOException {
-  const ProcessException(String this.executable,
-                         List<String> this.arguments,
-                         [String this.message = "",
-                          int this.errorCode = 0]);
-  String toString() {
-    var msg = (message == null) ? 'OS error code: $errorCode' : message;
-    var args = arguments.join(' ');
-    return "ProcessException: $msg\n  Command: $executable $args";
-  }
-
   /**
    * Contains the executable provided for the process.
    */
   final String executable;
 
   /**
    * Contains the arguments provided for the process.
    */
   final List<String> arguments;
 
   /**
    * Contains the system message for the process exception if any.
    */
   final String message;
 
   /**
    * Contains the OS error code for the process exception if any.
    */
   final int errorCode;
+
+  const ProcessException(this.executable, this.arguments, [this.message = "",
+                         this.errorCode = 0]);
+  String toString() {
+    var msg = (message == null) ? 'OS error code: $errorCode' : message;
+    var args = arguments.join(' ');
+    return "ProcessException: $msg\n  Command: $executable $args";
+  }
 }