SendPort + ReceivePort changes:

lib/isolate/frog/isolateimpl.dart

 // Copyright (c) 2012, 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.
 
 /**
  * A native object that is shared across isolates. This object is visible to all
  * isolates running on the same worker (either UI or background web worker).
  *
  * This is code that is intended to 'escape' the isolate boundaries in order to
  * implement the semantics of isolates in JavaScript. Without this we would have
@@ skipping 275 matching lines @@
   void postMessage(msg) native "return this.postMessage(msg);";
 }
 
 final String _SPAWNED_SIGNAL = "spawned";
 
 class _IsolateNatives {
 
   /** JavaScript-specific implementation to spawn an isolate. */
   static Future<SendPort> spawn(Isolate isolate, bool isLight) {
     Completer<SendPort> completer = new Completer<SendPort>();
-    ReceivePort port = new ReceivePort.singleShot();
+    ReceivePort port = new ReceivePort();
     port.receive((msg, SendPort replyPort) {
+      port.close();

[eub, 2012/03/09 18:33:10]

I wonder how often people are going to write this idiom.  Maybe
SingleShotReceivePort is worth still having around?

[eub, 2012/03/09 18:33:10]

I saw about a dozen instances looking over this CL.

[Siggi Cherem (dart-lang), 2012/03/10 03:10:00]

Yeah - this is something that I saw commonly in tests and places where the
parent isolate wanted to 'wait' for the child isolate before the vm finishes
executing. The trick is to keep a port open, so that the vm knows that we are
not done. 

Using singleShot for this purpose made the idiom shorter to write, but a little
harder to see in my opinion.

       assert(msg == _SPAWNED_SIGNAL);
       completer.complete(replyPort);
     });
 
     // TODO(floitsch): throw exception if isolate's class doesn't have a
     // default constructor.
     if (_globalState.useWorkers && !isLight) {
       _startWorker(isolate, port.toSendPort());
     } else {
       _startNonWorker(isolate, port.toSendPort());
@@ skipping 228 matching lines @@
     _fillStatics(_globalState.currentContext);
     ReceivePort port = new ReceivePort();
     replyTo.send(_SPAWNED_SIGNAL, port.toSendPort());
     isolate._run(port);
   }
 
   // TODO(sigmund): clean up above, after we make the new API the default:
 
   static _spawn2(String functionName, String uri, bool isLight) {
     Completer<SendPort> completer = new Completer<SendPort>();
-    ReceivePort port = new ReceivePort.singleShot();
+    ReceivePort port = new ReceivePort();
     port.receive((msg, SendPort replyPort) {
+      port.close();
       assert(msg == _SPAWNED_SIGNAL);
       completer.complete(replyPort);
     });
 
     SendPort signalReply = port.toSendPort();
 
     if (_globalState.useWorkers && !isLight) {
       _startWorker2(functionName, uri, signalReply);
     } else {
       _startNonWorker2(functionName, uri, signalReply);
@@ skipping 56 matching lines @@
       'command': 'start2',
       'id': workerId,
       // Note: we serialize replyPort twice because the child worker needs to
       // first deserialize the worker id, before it can correctly deserialize
       // the port (port deserialization is sensitive to what is the current
       // workerId).
       'replyTo': _serializeMessage(replyPort),
       'functionName': functionName }));
   }
 }