Big merge from experimental to bleeding edge.

sdk/lib/io/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.
 
 part of dart.io;
 
 class _FileInputStream extends _BaseDataInputStream implements InputStream {
   _FileInputStream(String name)
       : _data = const [],
         _position = 0,
         _filePosition = 0 {
     var file = new File(name);
     var future = file.open(FileMode.READ);
-    future.handleException((e) {
-      _reportError(e);
-      return true;
-    });
-    future.then(_setupOpenedFile);
+    future.then(_setupOpenedFile)
+          .catchError((e) {
+            _reportError(e.error);
+          });
   }
 
   _FileInputStream.fromStdio(int fd)
       : _data = const [],
         _position = 0,
         _filePosition = 0 {
     assert(fd == 0);
     _setupOpenedFile(_File._openStdioSync(fd));
   }
 
   void _setupOpenedFile(RandomAccessFile openedFile) {
     _openedFile = openedFile;
     if (_streamMarkedClosed) {
       // This input stream has already been closed.
       _fileLength = 0;
       _closeFile();
       return;
     }
     var futureOpen = _openedFile.length();
-    futureOpen.then((len) {
-      _fileLength = len;
-      _fillBuffer();
-    });
-    futureOpen.handleException((e) {
-      _reportError(e);
-      return true;
-    });
+    futureOpen
+      .then((len) {
+        _fileLength = len;
+        _fillBuffer();
+      })
+      .catchError((e) {
+        _reportError(e.error);
+      });
   }
 
   void _closeFile() {
     if (_openedFile == null) {
       _streamMarkedClosed = true;
       return;
     }
     if (available() == 0) _cancelScheduledDataCallback();
     if (!_openedFile.closed) {
       _openedFile.close().then((ignore) {
@@ skipping 19 matching lines @@
     future.then((data) {
       _data = data;
       _position = 0;
       _filePosition += _data.length;
       _activeFillBufferCall = false;
 
       if (_fileLength == _filePosition) {
         _closeFile();
       }
       _checkScheduleCallbacks();
-    });
-    future.handleException((e) {
+    }).catchError((e) {
       _activeFillBufferCall = false;
-      _reportError(e);
-      return true;
+      _reportError(e.error);
     });
   }
 
   int available() {
     return closed ? 0 : _data.length - _position;
   }
 
   void pipe(OutputStream output, {bool close: true}) {
     _pipe(this, output, close: close);
   }
@@ skipping 55 matching lines @@
 
 
 class _FileOutputStream extends _BaseOutputStream implements OutputStream {
   _FileOutputStream(String name, FileMode mode) {
     _pendingOperations = new List();
     var f = new File(name);
     var openFuture = f.open(mode);
     openFuture.then((openedFile) {
       _file = openedFile;
       _processPendingOperations();
-    });
-    openFuture.handleException((e) {
-      _reportError(e);
-      return true;
+    }).catchError((e) {
+      _reportError(e.error);
     });
   }
 
   _FileOutputStream.fromStdio(int fd) {
     assert(1 <= fd && fd <= 2);
     _file = _File._openStdioSync(fd);
   }
 
   bool write(List<int> buffer, [bool copyBuffer = false]) {
     var data = buffer;
@@ skipping 81 matching lines @@
   void _write(List<int> buffer, int offset, int len) {
     outstandingWrites++;
     var writeListFuture = _file.writeList(buffer, offset, len);
     writeListFuture.then((ignore) {
         outstandingWrites--;
         if (outstandingWrites == 0 &&
             !_streamMarkedClosed &&
             _onNoPendingWrites != null) {
           _onNoPendingWrites();
         }
-    });
-    writeListFuture.handleException((e) {
+    }).catchError((e) {
       outstandingWrites--;
-      _reportError(e);
-      return true;
+      _reportError(e.error);
     });
   }
 
   bool get closed => _streamMarkedClosed;
 
   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;
@@ skipping 71 matching lines @@
       throw new ArgumentError('${Error.safeToString(_name)} '
                               'is not a String');
     }
   }
 
   // Constructor from Path for file.
   _File.fromPath(Path path) : this(path.toNativePath());
 
   Future<bool> exists() {
     _ensureFileService();
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _EXISTS_REQUEST;
     request[1] = _name;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot open file '$_name'");
       }
       return response;
     });
   }
 
   external static _exists(String name);
 
   bool existsSync() {
     var result = _exists(_name);
     throwIfError(result, "Cannot check existence of file '$_name'");
     return result;
   }
 
   Future<File> create() {
     _ensureFileService();
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _CREATE_REQUEST;
     request[1] = _name;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot create file '$_name'");
       }
       return this;
     });
   }
 
   external static _create(String name);
 
   void createSync() {
     var result = _create(_name);
     throwIfError(result, "Cannot create file '$_name'");
   }
 
   Future<File> delete() {
     _ensureFileService();
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _DELETE_REQUEST;
     request[1] = _name;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot delete file '$_name'");
       }
       return this;
     });
   }
 
   external static _delete(String name);
 
   void deleteSync() {
     var result = _delete(_name);
     throwIfError(result, "Cannot delete file '$_name'");
   }
 
   Future<Directory> directory() {
     _ensureFileService();
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _DIRECTORY_REQUEST;
     request[1] = _name;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve directory for "
                                      "file '$_name'");
       }
       return new Directory(response);
     });
   }
 
   external static _directory(String name);
 
   Directory directorySync() {
     var result = _directory(name);
     throwIfError(result, "Cannot retrieve directory for file '$_name'");
     return new Directory(result);
   }
 
   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 ArgumentError());
+        completer.completeError(new ArgumentError());
       });
       return completer.future;
     }
-    List request = new List(3);
+    List request = new List.fixedLength(3);
     request[0] = _OPEN_REQUEST;
     request[1] = _name;
     request[2] = mode._mode;  // Direct int value for serialization.
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot open file '$_name'");
       }
       return new _RandomAccessFile(response, _name);
     });
   }
 
   Future<int> length() {
     _ensureFileService();
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _LENGTH_FROM_NAME_REQUEST;
     request[1] = _name;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve length of "
                                      "file '$_name'");
       }
       return response;
     });
   }
 
 
   external static _lengthFromName(String name);
 
   int lengthSync() {
     var result = _lengthFromName(_name);
     throwIfError(result, "Cannot retrieve length of file '$_name'");
     return result;
   }
 
   Future<Date> lastModified() {
     _ensureFileService();
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _LAST_MODIFIED_REQUEST;
     request[1] = _name;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve modification time "
                                      "for file '$_name'");
       }
       return new Date.fromMillisecondsSinceEpoch(response);
     });
   }
 
   external static _lastModified(String name);
@@ skipping 23 matching lines @@
   static RandomAccessFile _openStdioSync(int fd) {
     var id = _openStdio(fd);
     if (id == 0) {
       throw new FileIOException("Cannot open stdio file for: $fd");
     }
     return new _RandomAccessFile(id, "");
   }
 
   Future<String> fullPath() {
     _ensureFileService();
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _FULL_PATH_REQUEST;
     request[1] = _name;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve full path"
                                      " for '$_name'");
       }
       return response;
     });
   }
 
   external static _fullPath(String name);
@@ skipping 24 matching lines @@
     var stream = openInputStream();
     stream.onClosed = () {
       var result = chunks.readBytes(chunks.length);
       if (result == null) result = <int>[];
       completer.complete(result);
     };
     stream.onData = () {
       var chunk = stream.read();
       chunks.add(chunk);
     };
-    stream.onError = completer.completeException;
+    stream.onError = (e) {
+      completer.completeError(e);
+    };
     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;
   }
 
   Future<String> readAsString([Encoding encoding = Encoding.UTF_8]) {
     _ensureFileService();
-    return readAsBytes().transform((bytes) {
+    return readAsBytes().then((bytes) {
       if (bytes.length == 0) return "";
       var decoder = _StringDecoders.decoder(encoding);
       decoder.write(bytes);
       return decoder.decoded();
     });
   }
 
   String readAsStringSync([Encoding encoding = Encoding.UTF_8]) {
     var decoder = _StringDecoders.decoder(encoding);
     List<int> bytes = readAsBytesSync();
@@ skipping 14 matching lines @@
     var data = decoder.decoded();
     if (data != null) {
       result.add(data);
     }
     return result;
   }
 
   Future<List<String>> readAsLines([Encoding encoding = Encoding.UTF_8]) {
     _ensureFileService();
     Completer<List<String>> completer = new Completer<List<String>>();
-    return readAsBytes().transform((bytes) {
+    return readAsBytes().then((bytes) {
       var decoder = _StringDecoders.decoder(encoding);
       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);
@@ skipping 68 matching lines @@
 }
 
 
 class _RandomAccessFile extends _FileBase implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._name);
 
   Future<RandomAccessFile> close() {
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (closed) return _completeWithClosedException(completer);
     _ensureFileService();
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _CLOSE_REQUEST;
     request[1] = _id;
     // Set the id_ to 0 (NULL) to ensure the no more async requests
     // can be issued for this file.
     _id = 0;
-    return _fileService.call(request).transform((result) {
+    return _fileService.call(request).then((result) {
       if (result != -1) {
         _id = result;
         return this;
       } else {
         throw new FileIOException("Cannot close file '$_name'");
       }
     });
   }
 
   external static int _close(int id);
 
   void closeSync() {
     _checkNotClosed();
     var id = _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 (closed) return _completeWithClosedException(completer);
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _READ_BYTE_REQUEST;
     request[1] = _id;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "readByte failed for file '$_name'");
       }
       return response;
     });
   }
 
   external static _readByte(int id);
 
@@ skipping 17 matching lines @@
         completer.completeException(new FileIOException(
             "Invalid arguments to read for file '$_name'"));
       });
       return completer.future;
     };
     if (closed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _READ_REQUEST;
     request[1] = _id;
     request[2] = bytes;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "read failed for file '$_name'");
       }
       return response[1];
     });
   }
 
   external static _read(int id, int bytes);
 
   List<int> readSync(int bytes) {
     if (bytes is !int) {
       throw new FileIOException(
           "Invalid arguments to readSync for file '$_name'");
     }
     return _read(_id, bytes);
   }
 
   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(
+        completer.completeError(new FileIOException(
             "Invalid arguments to readList for file '$_name'"));
       });
       return completer.future;
     };
     if (closed) return _completeWithClosedException(completer);
-    List request = new List(3);
+    List request = new List.fixedLength(3);
     request[0] = _READ_LIST_REQUEST;
     request[1] = _id;
     request[2] = bytes;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "readList failed for file '$_name'");
       }
       var read = response[1];
       var data = response[2];
       buffer.setRange(offset, read, data);
       return read;
     });
   }
@@ skipping 25 matching lines @@
   }
 
   Future<RandomAccessFile> writeByte(int value) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (value 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(
+          completer.completeError(new FileIOException(
               "Invalid argument to writeByte for file '$_name'"));
       });
       return completer.future;
     }
     if (closed) return _completeWithClosedException(completer);
-    List request = new List(3);
+    List request = new List.fixedLength(3);
     request[0] = _WRITE_BYTE_REQUEST;
     request[1] = _id;
     request[2] = value;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "writeByte failed for file '$_name'");
       }
       return this;
     });
   }
 
   external static _writeByte(int id, int value);
 
@@ skipping 12 matching lines @@
   }
 
   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) {
       // 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(
+          completer.completeError(new FileIOException(
           "Invalid arguments to writeList for file '$_name'"));
       });
       return completer.future;
     }
     if (closed) return _completeWithClosedException(completer);
 
     _BufferAndOffset result;
     try {
       result = _ensureFastAndSerializableBuffer(buffer, offset, bytes);
     } catch (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));
+      new Timer(0, (t) => completer.completeError(e));
       return completer.future;
     }
 
-    List request = new List(5);
+    List request = new List.fixedLength(5);
     request[0] = _WRITE_LIST_REQUEST;
     request[1] = _id;
     request[2] = result.buffer;
     request[3] = result.offset;
     request[4] = bytes;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "writeList failed for file '$_name'");
       }
       return this;
     });
   }
 
   external static _writeList(int id, List<int> buffer, int offset, int bytes);
 
@@ skipping 13 matching lines @@
       throw new FileIOException("writeList failed for file '$_name'", result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeString(String string,
                                        [Encoding encoding = Encoding.UTF_8]) {
     if (encoding is! Encoding) {
       var completer = new Completer();
       new Timer(0, (t) {
-        completer.completeException(new FileIOException(
+        completer.completeError(new FileIOException(
             "Invalid encoding in writeString: $encoding"));
       });
       return completer.future;
     }
     var data = _StringEncoders.encoder(encoding).encodeString(string);
     return writeList(data, 0, data.length);
   }
 
   int writeStringSync(String string, [Encoding encoding = Encoding.UTF_8]) {
     if (encoding is! Encoding) {
       throw new FileIOException(
           "Invalid encoding in writeStringSync: $encoding");
     }
     var data = _StringEncoders.encoder(encoding).encodeString(string);
     return writeListSync(data, 0, data.length);
   }
 
   Future<int> position() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _POSITION_REQUEST;
     request[1] = _id;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "position failed for file '$_name'");
       }
       return response;
     });
   }
 
   external static _position(int id);
 
   int positionSync() {
     _checkNotClosed();
     var result = _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 (closed) return _completeWithClosedException(completer);
-    List request = new List(3);
+    List request = new List.fixedLength(3);
     request[0] = _SET_POSITION_REQUEST;
     request[1] = _id;
     request[2] = position;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "setPosition failed for file '$_name'");
       }
       return this;
     });
   }
 
   external static _setPosition(int id, int position);
 
   void setPositionSync(int position) {
     _checkNotClosed();
     var result = _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 (closed) return _completeWithClosedException(completer);
-    List request = new List(3);
+    List request = new List.fixedLength(3);
     request[0] = _TRUNCATE_REQUEST;
     request[1] = _id;
     request[2] = length;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "truncate failed for file '$_name'");
       }
       return this;
     });
   }
 
   external static _truncate(int id, int length);
 
   void truncateSync(int length) {
     _checkNotClosed();
     var result = _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 (closed) return _completeWithClosedException(completer);
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _LENGTH_REQUEST;
     request[1] = _id;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "length failed for file '$_name'");
       }
       return response;
     });
   }
 
   external static _length(int id);
 
   int lengthSync() {
     _checkNotClosed();
     var result = _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 (closed) return _completeWithClosedException(completer);
-    List request = new List(2);
+    List request = new List.fixedLength(2);
     request[0] = _FLUSH_REQUEST;
     request[1] = _id;
-    return _fileService.call(request).transform((response) {
+    return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "flush failed for file '$_name'");
       }
       return this;
     });
   }
 
   external static _flush(int id);
 
@@ skipping 16 matching lines @@
   bool get closed => _id == 0;
 
   void _checkNotClosed() {
     if (closed) {
       throw new FileIOException("File closed '$_name'");
     }
   }
 
   Future _completeWithClosedException(Completer completer) {
     new Timer(0, (t) {
-      completer.completeException(
+      completer.completeError(
           new FileIOException("File closed '$_name'"));
     });
     return completer.future;
   }
 
   final String _name;
   int _id;
 
   SendPort _fileService;
 }