adding codereview file, formatting, adding gitignore

lib/isolaterunner.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.
 
 library dart.pkg.isolate.isolaterunner;
 
 import "dart:isolate";
 import "dart:async";
 import "runner.dart";
 import "ports.dart";
@@ skipping 41 matching lines @@
    * Create a new [Isolate], as by [Isolate.spawn] and wrap that.
    *
    * The returned [IsolateRunner] forwards operations to the new isolate,
    * and keeps a port open in the new isolate that receives commands
    * from the `IsolateRunner`. Remember to [close] the `IsolateRunner` when
    * it's no longer needed.
    */
   static Future<IsolateRunner> spawn() {
     Completer portCompleter = new Completer.sync();
     SendPort initPort = singleCompletePort(portCompleter);
-    return Isolate.spawn(IsolateRunnerRemote._create, initPort)
-                  .then((Isolate isolate) {
-                    // TODO: Add when VM supports it.
-                    // isolate.setErrorsFatal(false);
-                    return portCompleter.future.then((SendPort commandPort) {
-                      var result = new IsolateRunner(isolate, commandPort);
-                      // Guarantees that setErrorsFatal has completed.
-                      return result.ping().then((_) => result);
-                    });
-                  });
+    return Isolate.spawn(IsolateRunnerRemote._create, initPort).then(
+        (Isolate isolate) {

[Lasse Reichstein Nielsen, 2015/02/26 10:59:14]

Also has body less indented than its delimiter line. Indent the body by at least
four more.

+      // TODO: Add when VM supports it.
+      // isolate.setErrorsFatal(false);
+      return portCompleter.future.then((SendPort commandPort) {
+        var result = new IsolateRunner(isolate, commandPort);
+        // Guarantees that setErrorsFatal has completed.
+        return result.ping().then((_) => result);
+      });
+    });
   }
 
   /**
    * Closes the `IsolateRunner` communication down.
    *
    * If the isolate isn't running something else to keep it alive,
    * this will also make the isolate shut down.
    *
    * Can be used to create an isolate, use [run] to start a service, and
    * then drop the connection and let the service control the isolate's
@@ skipping 49 matching lines @@
    * or doesn't answer within [timeout] for any other reason,
    * the returned future completes with `false`.
    *
    * Guaranteed to only complete after all previous sent isolate commands
    * (like pause and resume) have been handled.
    * Paused isolates do respond to ping requests.
    */
   Future<bool> ping({Duration timeout: const Duration(seconds: 1)}) {
     Completer completer = new Completer<bool>();
     SendPort port = singleCompletePort(completer,
-                                       callback: _kTrue,
-                                       timeout: timeout,
-                                       onTimeout: _kFalse);
+        callback: _kTrue, timeout: timeout, onTimeout: _kFalse);

[Lasse Reichstein Nielsen, 2015/02/26 10:59:13]

I prefer the original.

     isolate.ping(port);
     return completer.future;
   }
 
   static bool _kTrue(_) => true;
   static bool _kFalse() => false;
 
   /**
    * Pauses the isolate.
    *
@@ skipping 43 matching lines @@
    *
    * Example:
    *
    *     IsolateRunner iso = await IsolateRunner.spawn();
    *     try {
    *       return await iso.run(heavyComputation, argument);
    *     } finally {
    *       await iso.close();
    *     }
    */
-  Future run(function(argument), argument,
-             {Duration timeout, onTimeout()}) {
+  Future run(function(argument), argument, {Duration timeout, onTimeout()}) {
     return singleResultFuture((SendPort port) {
-      _commandPort.send(
-          list4(_RUN, FunctionRef.from(function), argument, port));
+      _commandPort
+          .send(list4(_RUN, FunctionRef.from(function), argument, port));
     }, timeout: timeout, onTimeout: onTimeout);
   }
 
   /**
    * A broadcast stream of uncaught errors from the isolate.
    *
    * When listening on the stream, errors from the isolate will be reported
    * as errors in the stream. Be ready to handle the errors.
    *
    * The stream closes when the isolate shuts down.
    */
   Stream get errors {
     StreamController controller;
     RawReceivePort port;
     void handleError(message) {
       if (message == null) {
         // Isolate shutdown.
         port.close();
         controller.close();
       } else {
         // Uncaught error.
         String errorDescription = message[0];
         String stackDescription = message[1];
         var error = new RemoteError(errorDescription, stackDescription);
         controller.addError(error, error.stackTrace);
       }
     }
-    controller = new StreamController.broadcast(
-        sync: true,
-        onListen: () {
-          port = new RawReceivePort(handleError);
-          // TODO: When supported, uncomment this.
-          // isolate.addErrorListener(port.sendPort);
-          // isolate.addOnExitListener(port.sendPort);
-          // And remove the send below, which acts as an immediate close.
-          port.sendPort.send(null);
-        },
-        onCancel: () {
-          port.close();
-          // this.removeErrorListener(port.sendPort);
-          // this.removeOnExitListener(port.sendPort);
-          port = null;
-        });
+    controller = new StreamController.broadcast(sync: true, onListen: () {
+      port = new RawReceivePort(handleError);
+      // TODO: When supported, uncomment this.
+      // isolate.addErrorListener(port.sendPort);
+      // isolate.addOnExitListener(port.sendPort);
+      // And remove the send below, which acts as an immediate close.
+      port.sendPort.send(null);
+    }, onCancel: () {
+      port.close();
+      // this.removeErrorListener(port.sendPort);
+      // this.removeOnExitListener(port.sendPort);
+      port = null;
+    });

[Lasse Reichstein Nielsen, 2015/02/26 10:59:13]

Less consistently indented. I'd prefer the onListen: and onCancel: to be
indented at the same level.

     return controller.stream;
   }
 
   /**
    * Waits for the [isolate] to terminate.
    *
    * Completes the returned future when the isolate terminates.
    *
    * If the isolate has already stopped responding to commands,
    * the returned future will never terminate.
@@ skipping 40 matching lines @@
     switch (command[0]) {
       case _SHUTDOWN:
         SendPort responsePort = command[1];
         _commandPort.close();
         responsePort.send(null);
         return;
       case _RUN:
         Function function = command[1].function;
         var argument = command[2];
         SendPort responsePort = command[3];
-        sendFutureResult(new Future.sync(() => function(argument)),
-                         responsePort);
+        sendFutureResult(
+            new Future.sync(() => function(argument)), responsePort);

[Lasse Reichstein Nielsen, 2015/02/26 10:59:14]

It's not as visible that responsePort is a second argument to sendFutureResult,
and not an argument to Future.sync.
I prefer the original.

         return;
     }
   }
 }