SendPort + ReceivePort changes:

runtime/vm/snapshot_test.dart

 // Copyright (c) 2011, 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.
 
 #import("dart:isolate");
 
 class Fields  {
   Fields(int i, int j) : fld1 = i, fld2 = j, fld5 = true {}
   int fld1;
   final int fld2;
@@ skipping 1221 matching lines @@
 class IsolateExitHandlerTest extends Isolate {
   static int counter;
 
   IsolateExitHandlerTest() : super.heavy();
 
   static void testMain() {
     Isolate.setExitHandler(() {
       Expect.equals(1, counter);
     });
     new IsolateExitHandlerTest().spawn().then((SendPort p) {
-      p.call("bar").receive((msg, replyTo) {
+      p.call("bar").then((msg) {
         counter++;
       });
     });
   }
 
   void main() {
     bool encounteredException = false;
     try {
       Isolate.setExitHandler(() {
         Expect.equals(true, false);
@@ skipping 21 matching lines @@
 class SpawnTest {
 
   static void testMain() {
     spawnIsolate();
   }
 
   static void spawnIsolate() {
     IsolateTestFramework.waitForDone();
     SpawnedIsolate isolate = new SpawnedIsolate();
     isolate.spawn().then((SendPort port) {
-      port.call(42).receive((message, replyTo) {
+      port.call(42).then((message) {
         Expect.equals(42, message);
         IsolateTestFramework.done();
       });
     });
   }
 }
 
 class SpawnedIsolate extends Isolate {
 
   SpawnedIsolate() : super() { }
@@ skipping 37 matching lines @@
     this.port.receive((ignoredMessage, reply) {
       reply.send(field, null);
       this.port.close();
       IsolateTestFramework.done();
     });
   }
 
   static void testMain() {
     ConstructorTest test = new ConstructorTest();
     test.spawn().then((SendPort port) {
-      ReceivePort reply = port.call("ignored");
-      reply.receive((message, replyPort) {
+      port.call("ignored").then((message) {
         Expect.equals(499, message);
       });
     });
   }
 }
 
 // Dart test program for testing isolate communication with
 // simple messages.
 // ImportOptions=IsolateTestFramework
 
@@ skipping 23 matching lines @@
 
 // ---------------------------------------------------------------------------
 // Request-reply test.
 // ---------------------------------------------------------------------------
 
 class RequestReplyTest {
 
   static void test() {
     testCall();
     testSend();
-    testSendSingleShot();
   }
 
   static void testCall() {
     IsolateTest.waitForDone();
     new RequestReplyIsolate().spawn().then((SendPort port) {
-      port.call(42).receive((message, replyTo) {
+      port.call(42).then((message) {
         Expect.equals(42 + 87, message);
         IsolateTest.done();
       });
     });
   }
 
   static void testSend() {
     IsolateTest.waitForDone();
     new RequestReplyIsolate().spawn().then((SendPort port) {
       ReceivePort reply = new ReceivePort();
       port.send(99, reply.toSendPort());
       reply.receive((message, replyTo) {
         Expect.equals(99 + 87, message);
         reply.close();
         IsolateTest.done();
       });
     });
   }
-
-  static void testSendSingleShot() {
-    IsolateTest.waitForDone();
-    new RequestReplyIsolate().spawn().then((SendPort port) {
-      ReceivePort reply = new ReceivePort.singleShot();
-      port.send(99, reply.toSendPort());
-      reply.receive((message, replyTo) {
-        Expect.equals(99 + 87, message);
-        IsolateTest.done();
-      });
-    });
-  }
-
 }
 
 
 class RequestReplyIsolate extends Isolate {
 
   RequestReplyIsolate() : super() { }
 
   void main() {
     this.port.receive((message, SendPort replyTo) {
       replyTo.send(message + 87, null);
@@ skipping 82 matching lines @@
 
   static String state;
 
   static void test() {
     IsolateTest.waitForDone();
     Expect.equals(null, state);
     state = "foo";
     Expect.equals("foo", state);
 
     new StaticStateIsolate().spawn().then((SendPort remote) {
-      remote.call("bar").receive((reply, replyTo) {
+      remote.call("bar").then((reply) {
         Expect.equals("foo", state);
         Expect.equals(null, reply);
 
         state = "baz";
-        remote.call("exit").receive((reply, replyTo) {
+        remote.call("exit").then((reply) {
           Expect.equals("baz", state);
           Expect.equals("bar", reply);
           IsolateTest.done();
         });
       });
     });
   }
 
 }
 
@@ skipping 40 matching lines @@
     IsolateTestFramework.waitForDone();
     new LogIsolate().spawn().then((SendPort remote) {
 
       remote.send(1, null);
       remote.send("Hello", null);
       remote.send("World", null);
       remote.send(const [null, 1, 2, 3, 4], null);
       remote.send(const [1, 2.0, true, false, 0xffffffffff], null);
       remote.send(const ["Hello", "World", 0xffffffffff], null);
       // Shutdown the LogRunner.
-      remote.call(-1).receive((int message, SendPort replyTo) {
+      remote.call(-1).then((int message) {
         Expect.equals(6, message);
       });
       IsolateTestFramework.done();
     });
   }
 }
 
 
 class LogIsolate extends Isolate {
   LogIsolate() : super() { }
@@ skipping 113 matching lines @@
 }
 
 class PingPongClient {
   static void test() {
     IsolateTestFramework.waitForDone();
     new PingPongServer().spawn().then((SendPort remote) {
 
       // Send objects and receive them back.
       for (int i = 0; i < MessageTest.elms.length; i++) {
         var sentObject = MessageTest.elms[i];
-        remote.call(sentObject).receive(
-            (var receivedObject, SendPort replyTo) {
-              MessageTest.VerifyObject(i, receivedObject);
-            });
+        remote.call(sentObject).then((var receivedObject) {
+            MessageTest.VerifyObject(i, receivedObject);
+          });
       }
 
       // Send recursive objects and receive them back.
       List local_list1 = ["Hello", "World", "Hello", 0xffffffffff];
       List local_list2 = [null, local_list1, local_list1 ];
       List local_list3 = [local_list2, 2.0, true, false, 0xffffffffff];
       List sendObject = new List(5);
       sendObject[0] = local_list1;
       sendObject[1] = sendObject;
       sendObject[2] = local_list2;
       sendObject[3] = sendObject;
       sendObject[4] = local_list3;
-      remote.call(sendObject).receive(
-          (var replyObject, SendPort replyTo) {
-            Expect.equals(true, sendObject is List);
-            Expect.equals(true, replyObject is List);
-            Expect.equals(sendObject.length, replyObject.length);
-            Expect.equals(true, replyObject[1] === replyObject);
-            Expect.equals(true, replyObject[3] === replyObject);
-            Expect.equals(true, replyObject[0] === replyObject[2][1]);
-            Expect.equals(true, replyObject[0] === replyObject[2][2]);
-            Expect.equals(true, replyObject[2] === replyObject[4][0]);
-            Expect.equals(true, replyObject[0][0] === replyObject[0][2]);
-            // Bigint literals are not canonicalized so do a == check.
-            Expect.equals(true, replyObject[0][3] == replyObject[4][4]);
-          });
+      remote.call(sendObject).then((var replyObject) {
+          Expect.equals(true, sendObject is List);
+          Expect.equals(true, replyObject is List);
+          Expect.equals(sendObject.length, replyObject.length);
+          Expect.equals(true, replyObject[1] === replyObject);
+          Expect.equals(true, replyObject[3] === replyObject);
+          Expect.equals(true, replyObject[0] === replyObject[2][1]);
+          Expect.equals(true, replyObject[0] === replyObject[2][2]);
+          Expect.equals(true, replyObject[2] === replyObject[4][0]);
+          Expect.equals(true, replyObject[0][0] === replyObject[0][2]);
+          // Bigint literals are not canonicalized so do a == check.
+          Expect.equals(true, replyObject[0][3] == replyObject[4][4]);
+        });
 
       // Shutdown the MessageServer.
-      remote.call(-1).receive(
-          (int message, SendPort replyTo) {
-            Expect.equals(MessageTest.elms.length + 1, message);
-            IsolateTestFramework.done();
-          });
+      remote.call(-1).then((int message) {
+          Expect.equals(MessageTest.elms.length + 1, message);
+          IsolateTestFramework.done();
+        });
     });
   }
 }
 
 class PingPongServer extends Isolate {
   PingPongServer() : super() {}
 
   void main() {
     print("Starting server.");
     int count = 0;
@@ skipping 79 matching lines @@
 
 
 class LineProcessorClient {
 
   LineProcessorClient(MandelbrotState this._state, int this._id) {
     _out = new LineProcessor().spawn();
   }
 
   void processLine(int y) {
     _out.then((SendPort p) {
-      p.call(y).receive((List<int> message, SendPort replyTo) {
+      p.call(y).then((List<int> message) {
         _state.notifyProcessedLine(this, y, message);
       });
     });
   }
 
   void shutdown() {
     _out.then((SendPort p) {
       p.send(MandelIsolateTest.TERMINATION_MESSAGE, null);
     });
   }
@@ skipping 51 matching lines @@
 
 // Dart test program for testing that isolates are spawned.
 // ImportOptions=IsolateTestFramework
 
 class IsolateNegativeTest extends Isolate {
   IsolateNegativeTest() : super();
 
   static void testMain() {
     IsolateTestFramework.waitForDone();
     new IsolateNegativeTest().spawn().then((SendPort port) {
-      port.call("foo").receive((message, replyTo) {
+      port.call("foo").then((message) {
         Expect.equals(true, false);   // <=-------- Should fail here.
         IsolateTestFramework.done();
       });
     });
   }
 
   void main() {
     this.port.receive((ignored, replyTo) {
       replyTo.send("foo", null);
     });
   }
 }