- Make sure to keep the main/control port opened until the

runtime/lib/isolate_patch.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.
 
 patch class ReceivePort {
   /* patch */ factory ReceivePort() = _ReceivePortImpl;
 
   /* patch */ factory ReceivePort.fromRawReceivePort(RawReceivePort rawPort) =
       _ReceivePortImpl.fromRawReceivePort;
 }
@@ skipping 133 matching lines @@
   }
 
   // Forward the implementation of sending messages to the VM. Only port ids
   // are being handed to the VM.
   static _sendInternal(int sendId, int replyId, var message)
       native "SendPortImpl_sendInternal_";
 
   final int _id;
 }
 
-_getPortInternal() native "isolate_getPortInternal";
-
 typedef _MainFunction();
 typedef _MainFunctionArgs(args);
 typedef _MainFunctionArgsMessage(args, message);
 
 /**
  * Takes the real entry point as argument and invokes it with the initial
  * message.
  *
- * The initial message is (currently) received through the global port variable.
+ * The initial message is received through the control port variable.
  */
 void _startIsolate(Function entryPoint, bool isSpawnUri) {
-  Isolate._port.first.then((message) {
+  ignoreHandler(message) {
+    // Messages on the current Isolate's control port are dropped after the
+    // initial startup message has been received.
+  }
+
+  isolateStartHandler(message) {
+    // We received the initial startup message. Ignore all further messages.
+    Isolate._self.handler = ignoreHandler;
+
     SendPort replyTo = message[0];
     // TODO(floitsch): don't send ok-message if we can't find the entry point.
     replyTo.send("started");
     if (isSpawnUri) {
       assert(message.length == 3);
       List<String> args = message[1];
       var isolateMessage = message[2];
       if (entryPoint is _MainFunctionArgsMessage) {
         entryPoint(args, isolateMessage);
       } else if (entryPoint is _MainFunctionArgs) {
         entryPoint(args);
       } else {
         entryPoint();
       }
     } else {
       assert(message.length == 2);
       var entryMessage = message[1];
       entryPoint(entryMessage);
     }
-  });
+  }
+
+  Isolate._self.handler = isolateStartHandler;
 }
 
 patch class Isolate {
   /* patch */ static Future<Isolate> spawn(
       void entryPoint(message), var message) {
     Completer completer = new Completer<Isolate>.sync();
     try {
       // The VM will invoke [_startIsolate] with entryPoint as argument.
       SendPort controlPort = _spawnFunction(entryPoint);
       RawReceivePort readyPort = new RawReceivePort();
@@ skipping 23 matching lines @@
         readyPort.close();
         completer.complete(new Isolate._fromControlPort(controlPort));
       };
     } catch(e, st) {
       // TODO(floitsch): we want errors to go into the returned future.
       rethrow;
     };
     return completer.future;
   }
 
-  static final ReceivePort _port =
-      new ReceivePort.fromRawReceivePort(_getPortInternal());
+  static final RawReceivePort _self = _mainPort;
+  static RawReceivePort get _mainPort native "Isolate_mainPort";
 
   static SendPort _spawnFunction(Function topLevelFunction)
-      native "isolate_spawnFunction";
+      native "Isolate_spawnFunction";
 
-  static SendPort _spawnUri(String uri) native "isolate_spawnUri";
+  static SendPort _spawnUri(String uri) native "Isolate_spawnUri";
 }