Finish file 'fuzzer' and fix issues.

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;
     var chained = file.open(FileMode.READ).chain((openedFile) {
@@ skipping 404 matching lines @@
   }
 }
 
 // Class for encapsulating the native implementation of files.
 class _File extends _FileBase implements File {
   // Constructor for file.
   _File(String this._name);
 
   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) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response, "Cannot open file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(response);
+        throw _exceptionFromResponse(response, "Cannot open file '$_name'");
       }
+      return response;
     });
-    return completer.future;
   }
 
   bool existsSync() {
     return _FileUtils.checkedExists(_name);
   }
 
   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) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response, "Cannot create file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(this);
+        throw _exceptionFromResponse(response, "Cannot create file '$_name'");
       }
+      return this;
     });
-    return completer.future;
   }
 
   void createSync() {
     bool created = _FileUtils.checkedCreate(_name);
     if (!created) {
       throw new FileIOException("Cannot create file '$_name'");
     }
   }
 
   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) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response, "Cannot delete file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(this);
+        throw _exceptionFromResponse(response, "Cannot delete file '$_name'");
       }
+      return this;
     });
-    return completer.future;
   }
 
   void deleteSync() {
     _FileUtils.checkedDelete(_name);
   }
 
   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) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "Cannot retrieve directory for "
-                                       "file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(new Directory(response));
+        throw _exceptionFromResponse(response,
+                                     "Cannot retrieve directory for "
+                                     "file '$_name'");
       }
+      return new Directory(response);
     });
-    return completer.future;
   }
 
   Directory directorySync() {
     _FileUtils.checkedDirectory(_name);
     return new Directory(_FileUtils.directory(_name));
   }
 
   Future<RandomAccessFile> open([FileMode mode = FileMode.READ]) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       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) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response, "Cannot open file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(new _RandomAccessFile(response, _name));
+        throw _exceptionFromResponse(response, "Cannot open file '$_name'");
       }
+      return new _RandomAccessFile(response, _name);
     });
-    return completer.future;
   }
 
   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) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "Cannot retrieve length of "
-                                       "file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(response);
+        throw _exceptionFromResponse(response,
+                                     "Cannot retrieve length of "
+                                     "file '$_name'");
       }
+      return 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 13 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, "");
   }
 
   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) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "Cannot retrieve full path"
-                                       " for '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(response);
+        throw _exceptionFromResponse(response,
+                                     "Cannot retrieve full path"
+                                     " for '$_name'");
       }
+      return response;
     });
-    return completer.future;
   }
 
   String fullPathSync() {
     return _FileUtils.checkedFullPath(_name);
   }
 
   InputStream openInputStream() {
     return new _FileInputStream(_name);
   }
 
@@ skipping 103 matching lines @@
   Future<RandomAccessFile> close() {
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (_isClosed) return _completeWithClosedException(completer);
     _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) {
+    return _fileService.call(request).transform((result) {
       if (result != -1) {
         _id = result;
-        completer.complete(this);
+        return this;
       } else {
-        completer.completeException(
-            new FileIOException("Cannot close file '$_name'"));
+        throw 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;
   }
 
   Future<int> readByte() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _FileUtils.kReadByteRequest;
     request[1] = _id;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "readByte failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(response);
+        throw _exceptionFromResponse(response,
+                                     "readByte failed for file '$_name'");
       }
+      return 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;
   }
 
   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) {
       // 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;
     };
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _FileUtils.kReadListRequest;
     request[1] = _id;
     request[2] = bytes;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        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);
-        completer.complete(read);
+        throw _exceptionFromResponse(response,
+                                     "readList failed for file '$_name'");
       }
+      var read = response[1];
+      var data = response[2];
+      buffer.setRange(offset, read, data);
+      return 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 =
@@ skipping 20 matching lines @@
           completer.completeException(new FileIOException(
               "Invalid argument to writeByte for file '$_name'"));
       });
       return completer.future;
     }
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _FileUtils.kWriteByteRequest;
     request[1] = _id;
     request[2] = value;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "writeByte failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(this);
+        throw _exceptionFromResponse(response,
+                                     "writeByte failed for file '$_name'");
       }
+      return 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) {
@@ skipping 11 matching lines @@
       // 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 completer.future;
     }
     if (_isClosed) return _completeWithClosedException(completer);
 
-    List result =
-        _FileUtils.ensureFastAndSerializableBuffer(buffer, offset, bytes);
+    List result;
+    try {
+      result =
+          _FileUtils.ensureFastAndSerializableBuffer(buffer, offset, bytes);
+    } catch (var e) {
+      // 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(e));
+      return completer.future;
+    }
     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;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "writeList failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(this);
+        throw _exceptionFromResponse(response,
+                                     "writeList failed for file '$_name'");
       }
+      return 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 =
@@ skipping 10 matching lines @@
 
   Future<RandomAccessFile> writeString(String string,
                                        [Encoding encoding = Encoding.UTF_8]) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _FileUtils.kWriteStringRequest;
     request[1] = _id;
     request[2] = string;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "writeString failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(this);
+        throw _exceptionFromResponse(response,
+                                     "writeString failed for file '$_name'");
       }
+      return 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;
   }
 
   Future<int> position() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _FileUtils.kPositionRequest;
     request[1] = _id;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "position failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(response);
+        throw _exceptionFromResponse(response,
+                                     "position failed for file '$_name'");
       }
+      return 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;
   }
 
   Future<RandomAccessFile> setPosition(int position) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _FileUtils.kSetPositionRequest;
     request[1] = _id;
     request[2] = position;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "setPosition failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(this);
+        throw _exceptionFromResponse(response,
+                                     "setPosition failed for file '$_name'");
       }
+      return 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);
     }
   }
 
   Future<RandomAccessFile> truncate(int length) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _FileUtils.kTruncateRequest;
     request[1] = _id;
     request[2] = length;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "truncate failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(this);
+        throw _exceptionFromResponse(response,
+                                     "truncate failed for file '$_name'");
       }
+      return 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);
     }
   }
 
   Future<int> length() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _FileUtils.kLengthRequest;
     request[1] = _id;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "length failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(response);
+        throw _exceptionFromResponse(response,
+                                     "length failed for file '$_name'");
       }
+      return 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;
   }
 
   Future<RandomAccessFile> flush() {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (_isClosed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _FileUtils.kFlushRequest;
     request[1] = _id;
-    _fileService.call(request).then((response) {
+    return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
-        var e = _exceptionFromResponse(response,
-                                       "flush failed for file '$_name'");
-        completer.completeException(e);
-      } else {
-        completer.complete(this);
+        throw _exceptionFromResponse(response,
+                                     "flush failed for file '$_name'");
       }
+      return 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);
     }
   }
 
@@ skipping 19 matching lines @@
           new FileIOException("File closed '$_name'"));
     });
     return completer.future;
   }
 
   final String _name;
   int _id;
 
   SendPort _fileService;
 }