SendPort + ReceivePort changes:

runtime/bin/file_impl.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.
 
 class _FileInputStream extends _BaseDataInputStream implements InputStream {
   _FileInputStream(String name) {
     _file = new File(name);
     _data = [];
     _position = 0;
     _file.onError = (String s) {
@@ skipping 312 matching lines @@
     _asyncUsed = true;
     if (_name is !String) {
       if (_onError != null) {
         _onError('File name is not a string: $_name');
       }
       return;
     }
     List request = new List(2);
     request[0] = _FileUtils.kExistsRequest;
     request[1] = _name;
-    _fileService.call(request).receive((exists, replyTo) {
+    _fileService.call(request).then((exists) {
       callback(exists);
     });
   }
 
   bool existsSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     if (_name is !String) {
       throw new FileIOException('File name is not a string: $_name');
     }
     return _FileUtils.exists(_name);
   }
 
   void create(void callback()) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kCreateRequest;
     request[1] = _name;
-    _fileService.call(request).receive((created, replyTo) {
+    _fileService.call(request).then((created) {
       if (created) {
         callback();
       } else if (_onError != null) {
         _onError("Cannot create file: $_name");
       }
     });
   }
 
   void createSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool created = _FileUtils.checkedCreate(_name);
     if (!created) {
       throw new FileIOException("Cannot create file: $_name");
     }
   }
 
   void delete(void callback()) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kDeleteRequest;
     request[1] = _name;
-    _fileService.call(request).receive((deleted, replyTo) {
+    _fileService.call(request).then((deleted) {
       if (deleted) {
         callback();
       } else if (_onError != null) {
         _onError("Cannot delete file: $_name");
       }
     });
   }
 
   void deleteSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool deleted = _FileUtils.checkedDelete(_name);
     if (!deleted) {
       throw new FileIOException("Cannot delete file: $_name");
     }
   }
 
   void directory(void callback(Directory dir)) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kDirectoryRequest;
     request[1] = _name;
-    _fileService.call(request).receive((path, replyTo) {
+    _fileService.call(request).then((path) {
       if (path != null) {
         callback(new Directory(path));
       } else if (_onError != null) {
         _onError("Cannot get directory for: ${_name}");
       }
     });
   }
 
   Directory directorySync() {
     if (_asyncUsed) {
@@ skipping 15 matching lines @@
       if (_onError != null) {
         _onError("Unknown file mode. Use FileMode.READ, FileMode.WRITE " +
                  "or FileMode.APPEND.");
         return;
       }
     }
     List request = new List(3);
     request[0] = _FileUtils.kOpenRequest;
     request[1] = _name;
     request[2] = mode._mode;  // Direct int value for serialization.
-    _fileService.call(request).receive((id, replyTo) {
+    _fileService.call(request).then((id) {
       if (id != 0) {
         callback(new _RandomAccessFile(id, _name));
       } else if (_onError != null) {
         _onError("Cannot open file: $_name");
       }
     });
   }
 
   RandomAccessFile openSync([FileMode mode = FileMode.READ]) {
     if (_asyncUsed) {
@@ skipping 20 matching lines @@
     }
     return new _RandomAccessFile(id, "");
   }
 
   void fullPath(void callback(String result)) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kFullPathRequest;
     request[1] = _name;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result != null) {
         callback(result);
       } else if (_onError != null) {
         _onError("fullPath failed");
       }
     });
   }
 
   String fullPathSync() {
     if (_asyncUsed) {
@@ skipping 162 matching lines @@
   void close(void callback()) {
     if (_id == 0) return;
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kCloseRequest;
     request[1] = _id;
     // Set the id_ to 0 (NULL) to ensure the no more async requests
     // can be issues for this file.
     _id = 0;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result != -1) {
         _id = result;
         callback();
       } else if (_onError != null) {
         _onError("Cannot close file: $_name");
       }
     });
   }
 
   void closeSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     var id = _FileUtils.close(_id);
     if (id == -1) {
       throw new FileIOException("Cannot close file: $_name");
     }
     _id = id;
   }
 
   void readByte(void callback(int byte)) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kReadByteRequest;
     request[1] = _id;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result != -1) {
         callback(result);
       } else if (_onError != null) {
         _onError("readByte failed");
       }
     });
   }
 
   int readByteSync() {
     if (_asyncUsed) {
@@ skipping 14 matching lines @@
     if (buffer is !List || offset is !int || bytes is !int) {
       if (_onError != null) {
         _onError("Invalid arguments to readList");
       }
       return;
     };
     List request = new List(3);
     request[0] = _FileUtils.kReadListRequest;
     request[1] = _id;
     request[2] = bytes;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result is List && result.length == 2 && result[0] != -1) {
         var read = result[0];
         var data = result[1];
         buffer.setRange(offset, read, data);
         callback(read);
         return;
       } else if (_onError != null) {
         _onError(result is String ? result : "readList failed");
       }
     });
@@ skipping 27 matching lines @@
       if (_onError != null) {
         _onError("Invalid argument to writeByte");
       }
       return;
     }
     List request = new List(3);
     request[0] = _FileUtils.kWriteByteRequest;
     request[1] = _id;
     request[2] = value;
     _writeEnqueued();
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       _writeCompleted();
       if (result == -1 && _onError !== null) {
         _onError("writeByte failed");
       }
     });
   }
 
   int writeByteSync(int value) {
     if (_asyncUsed) {
       throw new FileIOException(
@@ skipping 24 matching lines @@
     List outBuffer = result[0];
     int outOffset = result[1];
 
     List request = new List(5);
     request[0] = _FileUtils.kWriteListRequest;
     request[1] = _id;
     request[2] = outBuffer;
     request[3] = outOffset;
     request[4] = bytes;
     _writeEnqueued();
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       _writeCompleted();
       if (result == -1 && _onError !== null) {
         _onError("writeList failed");
       }
     });
   }
 
   int writeListSync(List<int> buffer, int offset, int bytes) {
     if (_asyncUsed) {
       throw new FileIOException(
@@ skipping 16 matching lines @@
   }
 
   void writeString(String string) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kWriteStringRequest;
     request[1] = _id;
     request[2] = string;
     _writeEnqueued();
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       _writeCompleted();
       if (result == -1 && _onError !== null) {
         _onError("writeString failed");
       }
     });
   }
 
   int writeStringSync(String string) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.checkedWriteString(_id, string);
     if (result == -1) {
       throw new FileIOException("writeString failed");
     }
     return result;
   }
 
   void position(void callback(int position)) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kPositionRequest;
     request[1] = _id;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result != -1) {
         callback(result);
       } else if (_onError != null) {
         _onError("position failed");
       }
     });
   }
 
   int positionSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.position(_id);
     if (result == -1) {
       throw new FileIOException("position failed");
     }
     return result;
   }
 
   void setPosition(int position, void callback()) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kSetPositionRequest;
     request[1] = _id;
     request[2] = position;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result) {
         callback();
       } else if (_onError != null) {
         _onError("setPosition failed");
       }
     });
   }
 
   void setPositionSync(int position) {
     _ensureFileService();
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool result = _FileUtils.setPosition(_id, position);
     if (result == false) {
       throw new FileIOException("setPosition failed");
     }
   }
 
   void truncate(int length, void callback()) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kTruncateRequest;
     request[1] = _id;
     request[2] = length;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result) {
         callback();
       } else if (_onError != null) {
         _onError("truncate failed");
       }
     });
   }
 
   void truncateSync(int length) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool result = _FileUtils.truncate(_id, length);
     if (result == false) {
       throw new FileIOException("truncate failed");
     }
   }
 
   void length(void callback(int length)) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kLengthRequest;
     request[1] = _id;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result != -1) {
         callback(result);
       } else if (_onError != null) {
         _onError("length failed");
       }
     });
   }
 
   int lengthSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.length(_id);
     if (result == -1) {
       throw new FileIOException("length failed");
     }
     return result;
   }
 
   void flush(void callback()) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kFlushRequest;
     request[1] = _id;
-    _fileService.call(request).receive((result, replyTo) {
+    _fileService.call(request).then((result) {
       if (result != -1) {
         callback();
       } else if (_onError != null) {
         _onError("flush failed");
       }
     });
   }
 
   void flushSync() {
     if (_asyncUsed) {
@@ skipping 48 matching lines @@
   bool _asyncUsed;
   int _pendingWrites = 0;
 
   SendPort _fileService;
 
   Timer _noPendingWriteTimer;
 
   Function _onNoPendingWrites;
   Function _onError;
 }