Change dart:io to use Future for one-shot operations.

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) {
     var file = new File(name);
     _data = [];
     _position = 0;
-    file.onError = _reportError;
-    file.open(FileMode.READ, (openedFile) {
-      _readDataFromFile(openedFile);
+    var chained = file.open(FileMode.READ).chain((openedFile) {
+      return _readDataFromFile(openedFile);
+    });
+    chained.handleException((e) {
+      _reportError(e);
+      return true;
     });
   }
 
   _FileInputStream.fromStdio(int fd) {
     assert(fd == 0);
     var file = _File._openStdioSync(fd);
     _data = [];
     _position = 0;
-    _readDataFromFile(file);
+    _readDataFromFile(file).handleException((e) {
+      _reportError(e);
+      return true;
+    });
   }
 
-  void _readDataFromFile(RandomAccessFile openedFile) {
-    openedFile.onError = _reportError;
-    openedFile.length((length) {
+  Future<RandomAccessFile> _closeAfterRead(RandomAccessFile openedFile) {
+    return openedFile.close().transform((ignore) {
+      _streamMarkedClosed = true;
+      _checkScheduleCallbacks();
+      return openedFile;
+    });
+  }
+
+  Future<RandomAccessFile> _readDataFromFile(RandomAccessFile openedFile) {
+    return openedFile.length().chain((length) {
       var contents = new Uint8List(length);
       if (length != 0) {
-        openedFile.readList(contents, 0, length, (read) {
+        return openedFile.readList(contents, 0, length).chain((read) {
           if (read != length) {
-            _reportError(new FileIOException(
-                'Failed reading file contents in FileInputStream'));
+            throw new FileIOException(
+                'Failed reading file contents in FileInputStream');
           } else {
             _data = contents;
           }
-          openedFile.close(() {
-            _streamMarkedClosed = true;
-            _checkScheduleCallbacks();
-          });
+          return _closeAfterRead(openedFile);
         });
       } else {
-        openedFile.close(() {
-          _streamMarkedClosed = true;
-          _checkScheduleCallbacks();
-        });
+        return _closeAfterRead(openedFile);
       }
     });
   }
 
   int available() {
     return _closed ? 0 : _data.length - _position;
   }
 
   void pipe(OutputStream output, [bool close = true]) {
     _pipe(this, output, close: close);
@@ skipping 22 matching lines @@
   List<int> _data;
   int _position;
   bool _closed = false;
 }
 
 
 class _FileOutputStream extends _BaseOutputStream implements OutputStream {
   _FileOutputStream(String name, FileMode mode) {
     _pendingOperations = new List<List<int>>();
     var f = new File(name);
-    f.open(mode, (openedFile) {
+    var openFuture = f.open(mode);
+    openFuture.then((openedFile) {
       _file = openedFile;
-      _setupFileHandlers();
       _processPendingOperations();
     });
-    f.onError = _reportError;
+    openFuture.handleException((e) {
+      _reportError(e);
+      return true;
+    });
   }
 
   _FileOutputStream.fromStdio(int fd) {
     assert(1 <= fd && fd <= 2);
     _file = _File._openStdioSync(fd);
-    _setupFileHandlers();
-  }
-
-
-  void _setupFileHandlers() {
-    _file.onError = _reportError;
-    _file.onNoPendingWrites = () {
-      if (!_streamMarkedClosed && _onNoPendingWrites != null) {
-        _onNoPendingWrites();
-      }
-    };
   }
 
   bool write(List<int> buffer, [bool copyBuffer = false]) {
     var data = buffer;
     if (copyBuffer) {
       var length = buffer.length;
       data = new Uint8List(length);
       data.setRange(0, length, buffer, 0);
     }
     if (_file == null) {
@@ skipping 13 matching lines @@
     }
     var copy = new Uint8List(length);
     copy.setRange(0, length, buffer, offset);
     return write(copy);
   }
 
   void close() {
     if (_file == null) {
       _pendingOperations.add(null);
     } else if (!_streamMarkedClosed) {
-      _file.close(() {
+      _file.close().then((ignore) {
         if (_onClosed != null) _onClosed();
       });
       _streamMarkedClosed = true;
     }
   }
 
   void set onNoPendingWrites(void callback()) {
     _onNoPendingWrites = callback;
+    if (((_pendingOperations == null) || (_pendingOperations.length == 0)) &&
+        (outstandingWrites == 0) &&
+        !_streamMarkedClosed &&
+        (_onNoPendingWrites != null)) {
+      _onNoPendingWrites();

[Søren Gjesse, 2012/05/10 11:24:45]

Call this on the event loop using a Timer.

[Mads Ager (google), 2012/05/10 12:42:38]

Done.

+    }
   }
 
   void set onClosed(void callback()) {
     _onClosed = callback;
   }
 
   void _processPendingOperations() {
     _pendingOperations.forEach((buffer) {
       (buffer != null) ? write(buffer) : close();
     });
     _pendingOperations = null;
   }
 
   void _write(List<int> buffer, int offset, int len) {
-    _file.writeList(buffer, offset, len);
+    outstandingWrites++;
+    var writeListFuture = _file.writeList(buffer, offset, len);
+    writeListFuture.then((ignore) {
+        outstandingWrites--;
+        if ((outstandingWrites == 0) &&
+            !_streamMarkedClosed &&
+            (_onNoPendingWrites != null)) {
+          _onNoPendingWrites();
+        }
+    });
+    writeListFuture.handleException((e) {
+      outstandingWrites--;
+      _reportError(e);
+      return true;
+    });
   }
 
   RandomAccessFile _file;
 
   // When this is set to true the stream is marked closed. When a
   // stream is marked closed no more data can be written.
   bool _streamMarkedClosed = false;
 
   // When this is set to true the close callback has been called and
   // the stream is fully closed.
   bool _closeCallbackCalled = false;
 
+  // Number of writes that have not yet completed.
+  int outstandingWrites = 0;
+
   // List of pending writes that were issued before the underlying
   // file was successfully opened.
   List<List<int>> _pendingOperations;
 
   Function _onNoPendingWrites;
   Function _onClosed;
 }
 
 
 // Helper class containing static file helper methods.
@@ skipping 172 matching lines @@
 
   static int checkedWriteString(int id, String string) {
     if (string is !String) return -1;
     return writeString(id, string);
   }
 
 }
 
 // Base class for _File and _RandomAccessFile with shared functions.
 class _FileBase {
-  void _reportError(e) {
-    if (_onError != null) {
-      _onError(e);
-    } else {
-      throw e;
-    }
-  }
-
   bool _isErrorResponse(response) {
     return response is List && response[0] != _FileUtils.kSuccessResponse;
   }
 
-  void _handleErrorResponse(response, String message) {
+  Exception _exceptionFromResponse(response, String message) {
     assert(_isErrorResponse(response));
     switch (response[_FileUtils.kErrorResponseErrorType]) {
       case _FileUtils.kIllegalArgumentResponse:
-        _reportError(new IllegalArgumentException());
-        break;
+        return new IllegalArgumentException();
       case _FileUtils.kOSErrorResponse:
         var err = new OSError(response[_FileUtils.kOSErrorResponseMessage],
                               response[_FileUtils.kOSErrorResponseErrorCode]);
-        _reportError(new FileIOException(message, err));
-        break;
+        return new FileIOException(message, err);
       case _FileUtils.kFileClosedResponse:
-        _reportError(new FileIOException("File closed"));
-        break;
+        return new FileIOException("File closed");
       default:
-        _reportError(new Exception("Unknown error"));
-        break;
+        return new Exception("Unknown error");
     }
   }
-
-  void set onError(void handler(e)) {
-    _onError = handler;
-  }
-
-  Function _onError;
 }
 
 // Class for encapsulating the native implementation of files.
 class _File extends _FileBase implements File {
   // Constructor for file.
   _File(String this._name);
 
-  void exists(void callback(bool exists)) {
+  Future<bool> exists() {
     _ensureFileService();
+    Completer<bool> completer = new Completer<bool>();
     List request = new List(2);
     request[0] = _FileUtils.kExistsRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "Cannot open file '$_name'");
+        var e = _exceptionFromResponse(response, "Cannot open file '$_name'");
+        completer.completeException(e);
       } else {
-        callback(response);
+        completer.complete(response);
       }
     });
+    return completer.future;
   }
 
   bool existsSync() {
     return _FileUtils.checkedExists(_name);
   }
 
-  void create(void callback()) {
+  Future<File> create() {
     _ensureFileService();
+    Completer<File> completer = new Completer<File>();
     List request = new List(2);
     request[0] = _FileUtils.kCreateRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "Cannot create file");
+        var e = _exceptionFromResponse(response, "Cannot create file '$_name'");
+        completer.completeException(e);
       } else {
-        callback();
+        completer.complete(this);
       }
     });
+    return completer.future;
   }
 
   void createSync() {
     bool created = _FileUtils.checkedCreate(_name);
     if (!created) {
       throw new FileIOException("Cannot create file '$_name'");
     }
   }
 
-  void delete(void callback()) {
+  Future<File> delete() {
     _ensureFileService();
+    Completer<File> completer = new Completer<File>();
     List request = new List(2);
     request[0] = _FileUtils.kDeleteRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "Cannot delete file '$_name'");
+        var e = _exceptionFromResponse(response, "Cannot delete file '$_name'");
+        completer.completeException(e);
       } else {
-        callback();
+        completer.complete(this);
       }
     });
+    return completer.future;
   }
 
   void deleteSync() {
     _FileUtils.checkedDelete(_name);
   }
 
-  void directory(void callback(Directory dir)) {
+  Future<Directory> directory() {
     _ensureFileService();
+    Completer<Directory> completer = new Completer<Directory>();
     List request = new List(2);
     request[0] = _FileUtils.kDirectoryRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "Cannot retrieve directory for file");
+        var e = _exceptionFromResponse(response,
+                                       "Cannot retrieve directory for "
+                                       "file '$_name'");
+        completer.completeException(e);
       } else {
-        callback(new Directory(response));
+        completer.complete(new Directory(response));
       }
     });
+    return completer.future;
   }
 
   Directory directorySync() {
     _FileUtils.checkedDirectory(_name);
     return new Directory(_FileUtils.directory(_name));
   }
 
-  void open(FileMode mode, void callback(RandomAccessFile file)) {
+  Future<RandomAccessFile> open(FileMode mode) {
     _ensureFileService();
+    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
-      _reportError(new IllegalArgumentException());
-      return;
+      new Timer(0, (t) {
+        completer.completeException(new IllegalArgumentException());
+      });
+      return completer.future;
     }
     List request = new List(3);
     request[0] = _FileUtils.kOpenRequest;
     request[1] = _name;
     request[2] = mode._mode;  // Direct int value for serialization.
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "Cannot open file '$_name'");
+        var e = _exceptionFromResponse(response, "Cannot open file '$_name'");
+        completer.completeException(e);
       } else {
-        callback(new _RandomAccessFile(response, _name));
+        completer.complete(new _RandomAccessFile(response, _name));
       }
     });
+    return completer.future;
   }
 
-  void length(void callback(int length)) {
+  Future<int> length() {
     _ensureFileService();
+    Completer<int> completer = new Completer<int>();
     List request = new List(2);
     request[0] = _FileUtils.kLengthFromNameRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response,
-                             "Cannot retrieve length of file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "Cannot retrieve length of "
+                                       "file '$_name'");
+        completer.completeException(e);
       } else {
-        callback(response);
+        completer.complete(response);
       }
     });
+    return completer.future;
   }
 
   int lengthSync() {
     var result = _FileUtils.checkedLengthFromName(_name);
     if (result is OSError) {
       throw new FileIOException("Cannot retrieve length of file '$_name'",
                                 result);
     }
     return result;
   }
@@ skipping 11 matching lines @@
   }
 
   static RandomAccessFile _openStdioSync(int fd) {
     var id = _FileUtils.openStdio(fd);
     if (id == 0) {
       throw new FileIOException("Cannot open stdio file for: $fd");
     }
     return new _RandomAccessFile(id, "");
   }
 
-  void fullPath(void callback(String result)) {
+  Future<String> fullPath() {
     _ensureFileService();
+    Completer<String> completer = new Completer<String>();
     List request = new List(2);
     request[0] = _FileUtils.kFullPathRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "Cannot retrieve full path");
+        var e = _exceptionFromResponse(response,
+                                       "Cannot retrieve full path"
+                                       " for '$_name'");
+        completer.completeException(e);
       } else {
-        callback(response);
+        completer.complete(response);
       }
     });
+    return completer.future;
   }
 
   String fullPathSync() {
     return _FileUtils.checkedFullPath(_name);
   }
 
   InputStream openInputStream() {
     return new _FileInputStream(_name);
   }
 
   OutputStream openOutputStream([FileMode mode = FileMode.WRITE]) {
     if (mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileIOException(
           "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
     }
     return new _FileOutputStream(_name, mode);
   }
 
-  void readAsBytes(void callback(List<int> bytes)) {
+  Future<List<int>> readAsBytes() {
     _ensureFileService();
+    Completer<List<int>> completer = new Completer<List<int>>();
     var chunks = new _BufferList();
     var stream = openInputStream();
     stream.onClosed = () {
-      callback(chunks.readBytes(chunks.length));
+      completer.complete(chunks.readBytes(chunks.length));
     };
     stream.onData = () {
       var chunk = stream.read();
       chunks.add(chunk);
     };
-    stream.onError = (e) => _reportError(e);
+    stream.onError = completer.completeException;
+    return completer.future;
   }
 
   List<int> readAsBytesSync() {
     var opened = openSync();
     var length = opened.lengthSync();
     var result = new Uint8List(length);
     var read = opened.readListSync(result, 0, length);
     if (read != length) {
       throw new FileIOException("Failed to read file");
     }
     opened.closeSync();
     return result;
   }
 
-  void readAsText(Encoding encoding, void callback(String text)) {
+  Future<String> readAsText(Encoding encoding) {
     _ensureFileService();
     var decoder = _StringDecoders.decoder(encoding);
-    readAsBytes((bytes) {
-      try {
-        decoder.write(bytes);
-      } catch (var e) {
-        _reportError(e);
-        return;
-      }
-      callback(decoder.decoded);
+    return readAsBytes().transform((bytes) {
+      decoder.write(bytes);
+      return decoder.decoded;
     });
   }
 
   String readAsTextSync([Encoding encoding = Encoding.UTF_8]) {
     var decoder = _StringDecoders.decoder(encoding);
     List<int> bytes = readAsBytesSync();
     decoder.write(bytes);
     return decoder.decoded;
   }
 
   List<String> _getDecodedLines(_StringDecoder decoder) {
     List<String> result = [];
     var line = decoder.decodedLine;
     while (line != null) {
       result.add(line);
       line = decoder.decodedLine;
     }
     // If there is more data with no terminating line break we treat
     // it as the last line.
     var data = decoder.decoded;
     if (data != null) {
       result.add(data);
     }
     return result;
   }
 
-  void readAsLines(Encoding encoding, void callback(List<String> lines)) {
+  Future<List<String>> readAsLines(Encoding encoding) {
     _ensureFileService();
+    Completer<List<String>> completer = new Completer<List<String>>();
     var decoder = _StringDecoders.decoder(encoding);
-    readAsBytes((bytes) {
-      try {
-        decoder.write(bytes);
-      } catch (var e) {
-        _reportError(e);
-        return;
-      }
-      callback(_getDecodedLines(decoder));
+    return readAsBytes().transform((bytes) {
+      decoder.write(bytes);
+      return _getDecodedLines(decoder);
     });
   }
 
   List<String> readAsLinesSync([Encoding encoding = Encoding.UTF_8]) {
     var decoder = _StringDecoders.decoder(encoding);
     List<int> bytes = readAsBytesSync();
     decoder.write(bytes);
     return _getDecodedLines(decoder);
   }
 
   String get name() => _name;
 
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils.newServicePort();
     }
   }
 
-  String _name;
+  final String _name;
 
   SendPort _fileService;
 }
 
 
 class _RandomAccessFile extends _FileBase implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._name);
 
-  void close(void callback()) {
+  Future<RandomAccessFile> close() {
+    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (_id == 0) {
-      _reportError(new FileIOException("Cannot close file '$_name'"));
-      return;
+      // Complete asynchronously so the user has a chance to setup
+      // handlers without getting exceptions when registering the
+      // then handler.

[Søren Gjesse, 2012/05/10 11:24:45]

So we do always want to throw exceptions through the future - even if the
exception happens before the async part of the operation has been started?

[Mads Ager (google), 2012/05/10 12:42:38]

Yes, at least I did that consistently for the file operations. The reason for
doing that was that we called onError before if it was registered. If there is
no handleException on the future this will throw the exception in any case. 

+      new Timer(0, (t) {
+        completer.completeException(
+            new FileIOException("Cannot close file '$_name'"));
+      });
+      return completer.future;
     }
     _ensureFileService();
     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).then((result) {
       if (result != -1) {
         _id = result;
-        callback();
+        completer.complete(this);
       } else {
-        _reportError(new FileIOException("Cannot close file '$_name'"));
+        completer.completeException(
+            new FileIOException("Cannot close file '$_name'"));
       }
     });
+    return completer.future;
   }
 
   void closeSync() {
     var id = _FileUtils.close(_id);
     if (id == -1) {
       throw new FileIOException("Cannot close file '$_name'");
     }
     _id = id;
   }
 
-  void readByte(void callback(int byte)) {
+  Future<int> readByte() {
     _ensureFileService();
+    Completer<int> completer = new Completer<int>();
     List request = new List(2);
     request[0] = _FileUtils.kReadByteRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "readByte failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "readByte failed for file '$_name'");
+        completer.completeException(e);
       } else {
-        callback(response);
+        completer.complete(response);
       }
     });
+    return completer.future;
   }
 
   int readByteSync() {
     _checkNotClosed();
     var result = _FileUtils.readByte(_id);
     if (result is OSError) {
       throw new FileIOException("readByte failed for file '$_name'", result);
     }
     return result;
   }
 
-  void readList(List<int> buffer, int offset, int bytes,
-                void callback(int read)) {
+  Future<int> readList(List<int> buffer, int offset, int bytes) {
     _ensureFileService();
+    Completer<int> completer = new Completer<int>();
     if (buffer is !List || offset is !int || bytes is !int) {
-      _reportError(new FileIOException(
-          "Invalid arguments to readList for file '$_name'"));
-      return;
+      // Complete asynchronously so the user has a chance to setup
+      // handlers without getting exceptions when registering the
+      // then handler.
+      new Timer(0, (t) {
+        completer.completeException(new FileIOException(
+            "Invalid arguments to readList for file '$_name'"));
+      });
+      return completer.future;
     };
     List request = new List(3);
     request[0] = _FileUtils.kReadListRequest;
     request[1] = _id;
     request[2] = bytes;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "readList failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "readList failed for file '$_name'");
+        completer.completeException(e);
       } else {
         var read = response[1];
         var data = response[2];
         buffer.setRange(offset, read, data);
-        callback(read);
+        completer.complete(read);
       }
     });
+    return completer.future;
   }
 
   int readListSync(List<int> buffer, int offset, int bytes) {
     _checkNotClosed();
     if (buffer is !List || offset is !int || bytes is !int) {
       throw new FileIOException(
           "Invalid arguments to readList for file '$_name'");
     }
     if (bytes == 0) return 0;
     int index =
         _FileUtils.checkReadWriteListArguments(buffer.length, offset, bytes);
     if (index != 0) {
       throw new IndexOutOfRangeException(index);
     }
     var result = _FileUtils.readList(_id, buffer, offset, bytes);
     if (result is OSError) {
       throw new FileIOException("readList failed for file '$_name'",
                                 result);
     }
     return result;
   }
 
-  void writeByte(int value) {
+  Future<RandomAccessFile> writeByte(int value) {
     _ensureFileService();
+    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (value is !int) {
-      _reportError(new FileIOException(
-          "Invalid argument to writeByte for file '$_name'"));
-      return;
+      // Complete asynchronously so the user has a chance to setup
+      // handlers without getting exceptions when registering the
+      // then handler.
+      new Timer(0, (t) {
+          completer.completeException(new FileIOException(
+              "Invalid argument to writeByte for file '$_name'"));
+      });
+      return completer.future;
     }
     List request = new List(3);
     request[0] = _FileUtils.kWriteByteRequest;
     request[1] = _id;
     request[2] = value;
-    _writeEnqueued();
     _fileService.call(request).then((response) {
-      _writeCompleted();
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "writeByte failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "writeByte failed for file '$_name'");
+        completer.completeException(e);
+      } else {
+        completer.complete(this);
       }
     });
+    return completer.future;
   }
 
   int writeByteSync(int value) {
     _checkNotClosed();
     if (value is !int) {
       throw new FileIOException(
           "Invalid argument to writeByte for file '$_name'");
     }
     var result = _FileUtils.writeByte(_id, value);
     if (result is OSError) {
       throw new FileIOException("writeByte failed for file '$_name'",
                                 result);
     }
     return result;
   }
 
-  void writeList(List<int> buffer, int offset, int bytes) {
+  Future<RandomAccessFile> writeList(List<int> buffer, int offset, int bytes) {
     _ensureFileService();
+    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (buffer is !List || offset is !int || bytes is !int) {
-      _reportError(new FileIOException(
+      // Complete asynchronously so the user has a chance to setup
+      // handlers without getting exceptions when registering the
+      // then handler.
+      new Timer(0, (t) {
+          completer.completeException(new FileIOException(
           "Invalid arguments to writeList for file '$_name'"));
-      return;
+      });
+      return completer.future;
     }
 
     List result =
         _FileUtils.ensureFastAndSerializableBuffer(buffer, offset, bytes);
     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).then((response) {
-      _writeCompleted();
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "writeList failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "writeList failed for file '$_name'");
+        completer.completeException(e);
+      } else {
+        completer.complete(this);
       }
     });
+    return completer.future;
   }
 
   int writeListSync(List<int> buffer, int offset, int bytes) {
     _checkNotClosed();
     if (buffer is !List || offset is !int || bytes is !int) {
       throw new FileIOException(
           "Invalid arguments to writeList for file '$_name'");
     }
     if (bytes == 0) return 0;
     int index =
         _FileUtils.checkReadWriteListArguments(buffer.length, offset, bytes);
     if (index != 0) {
       throw new IndexOutOfRangeException(index);
     }
     var result = _FileUtils.writeList(_id, buffer, offset, bytes);
     if (result is OSError) {
       throw new FileIOException("writeList failed for file '$_name'", result);
     }
     return result;
   }
 
-  void writeString(String string, [Encoding encoding = Encoding.UTF_8]) {
+  Future<RandomAccessFile> writeString(String string,
+                                       [Encoding encoding = Encoding.UTF_8]) {
     _ensureFileService();
+    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     List request = new List(3);
     request[0] = _FileUtils.kWriteStringRequest;
     request[1] = _id;
     request[2] = string;
-    _writeEnqueued();
     _fileService.call(request).then((response) {
-      _writeCompleted();
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "writeString failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "writeString failed for file '$_name'");
+        completer.completeException(e);
+      } else {
+        completer.complete(this);
       }
     });
+    return completer.future;
   }
 
   int writeStringSync(String string, [Encoding encoding = Encoding.UTF_8]) {
     _checkNotClosed();
     var result = _FileUtils.checkedWriteString(_id, string);
     if (result is OSError) {
       throw new FileIOException("writeString failed for file '$_name'", result);
     }
     return result;
   }
 
-  void position(void callback(int position)) {
+  Future<int> position() {
     _ensureFileService();
+    Completer<int> completer = new Completer<int>();
     List request = new List(2);
     request[0] = _FileUtils.kPositionRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "position failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "position failed for file '$_name'");
+        completer.completeException(e);
       } else {
-        callback(response);
+        completer.complete(response);
       }
     });
+    return completer.future;
   }
 
   int positionSync() {
     _checkNotClosed();
     var result = _FileUtils.position(_id);
     if (result is OSError) {
       throw new FileIOException("position failed for file '$_name'", result);
     }
     return result;
   }
 
-  void setPosition(int position, void callback()) {
+  Future<RandomAccessFile> setPosition(int position) {
     _ensureFileService();
+    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     List request = new List(3);
     request[0] = _FileUtils.kSetPositionRequest;
     request[1] = _id;
     request[2] = position;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "setPosition failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "setPosition failed for file '$_name'");
+        completer.completeException(e);
       } else {
-        callback();
+        completer.complete(this);
       }
     });
+    return completer.future;
   }
 
   void setPositionSync(int position) {
     _checkNotClosed();
     var result = _FileUtils.setPosition(_id, position);
     if (result is OSError) {
       throw new FileIOException("setPosition failed for file '$_name'", result);
     }
   }
 
-  void truncate(int length, void callback()) {
+  Future<RandomAccessFile> truncate(int length) {
     _ensureFileService();
+    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     List request = new List(3);
     request[0] = _FileUtils.kTruncateRequest;
     request[1] = _id;
     request[2] = length;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "truncate failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "truncate failed for file '$_name'");
+        completer.completeException(e);
       } else {
-        callback();
+        completer.complete(this);
       }
     });
+    return completer.future;
   }
 
   void truncateSync(int length) {
     _checkNotClosed();
     var result = _FileUtils.truncate(_id, length);
     if (result is OSError) {
       throw new FileIOException("truncate failed for file '$_name'", result);
     }
   }
 
-  void length(void callback(int length)) {
+  Future<int> length() {
     _ensureFileService();
+    Completer<int> completer = new Completer<int>();
     List request = new List(2);
     request[0] = _FileUtils.kLengthRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "length failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "length failed for file '$_name'");
+        completer.completeException(e);
       } else {
-        callback(response);
+        completer.complete(response);
       }
     });
+    return completer.future;
   }
 
   int lengthSync() {
     _checkNotClosed();
     var result = _FileUtils.length(_id);
     if (result is OSError) {
       throw new FileIOException("length failed for file '$_name'", result);
     }
     return result;
   }
 
-  void flush(void callback()) {
+  Future<RandomAccessFile> flush() {
     _ensureFileService();
+    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     List request = new List(2);
     request[0] = _FileUtils.kFlushRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
-        _handleErrorResponse(response, "flush failed for file '$_name'");
+        var e = _exceptionFromResponse(response,
+                                       "flush failed for file '$_name'");
+        completer.completeException(e);
       } else {
-        callback();
+        completer.complete(this);
       }
     });
+    return completer.future;
   }
 
   void flushSync() {
     _checkNotClosed();
     var result = _FileUtils.flush(_id);
     if (result is OSError) {
       throw new FileIOException("flush failed for file '$_name'", result);
     }
   }
 
   String get name() => _name;
 
-  void set onNoPendingWrites(void handler()) {
-    _onNoPendingWrites = handler;
-    if (_pendingWrites == 0) {
-      _noPendingWriteTimer = new Timer(0, (t) {
-        if (_onNoPendingWrites != null) _onNoPendingWrites();
-      });
-    }
-  }
-
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils.newServicePort();
     }
   }
 
-  void _writeEnqueued() {
-    _pendingWrites++;
-    if (_noPendingWriteTimer != null) {
-      _noPendingWriteTimer.cancel();
-      _noPendingWriteTimer = null;
-    }
-  }
-
-  void  _writeCompleted() {
-    _pendingWrites--;
-    if (_pendingWrites == 0 && _onNoPendingWrites != null) {
-      _onNoPendingWrites();
-    }
-  }
-
   void _checkNotClosed() {
     if (_id == 0) {
       throw new FileIOException("File closed '$_name'");
     }
   }
 
-  String _name;
+  final String _name;
   int _id;
-  int _pendingWrites = 0;
 
   SendPort _fileService;
-
-  Timer _noPendingWriteTimer;
-
-  Function _onNoPendingWrites;
 }