Remove explicit delayed futures in dart:io.

sdk/lib/io/file_impl.dart

 // Copyright (c) 2013, 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;
 
 // Read the file in blocks of size 64k.
 const int _BLOCK_SIZE = 64 * 1024;
 
 
@@ skipping 320 matching lines @@
   external static _directory(String path);
 
   Directory directorySync() {
     var result = _directory(path);
     throwIfError(result, "Cannot retrieve directory for file '$_path'");
     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) {
-      Timer.run(() {
-        completer.completeError(new ArgumentError());
-      });
-      return completer.future;
+      return new Future.error(new ArgumentError());
     }
     List request = new List(3);
     request[0] = _OPEN_REQUEST;
     request[1] = _path;
     request[2] = mode._mode;  // Direct int value for serialization.
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot open file '$_path'");
       }
       return new _RandomAccessFile(response, _path);
@@ skipping 157 matching lines @@
         .transform(new StringDecoder(encoding))
         .transform(new LineTransformer())
         .listen((line) => list.add(line));
     controller.add(bytes);
     controller.close();
     return list;
   }
 
   Future<List<String>> readAsLines({Encoding encoding: Encoding.UTF_8}) {
     _ensureFileService();
-    Completer<List<String>> completer = new Completer<List<String>>();
     return readAsBytes().then((bytes) {
       return _decodeLines(bytes, encoding);
     });
   }
 
   List<String> readAsLinesSync({Encoding encoding: Encoding.UTF_8}) {
     return _decodeLines(readAsBytesSync(), encoding);
   }
 
   Future<File> writeAsBytes(List<int> bytes,
@@ skipping 13 matching lines @@
     opened.writeFromSync(bytes, 0, bytes.length);
     opened.closeSync();
   }
 
   Future<File> writeAsString(String contents,
                              {FileMode mode: FileMode.WRITE,
                               Encoding encoding: Encoding.UTF_8}) {
     try {
       return writeAsBytes(_encodeString(contents, encoding), mode: mode);
     } catch (e) {
-      var completer = new Completer();
-      Timer.run(() => completer.completeError(e));
-      return completer.future;
+      return new Future.error(e);
     }
   }
 
   void writeAsStringSync(String contents,
                          {FileMode mode: FileMode.WRITE,
                           Encoding encoding: Encoding.UTF_8}) {
     writeAsBytesSync(_encodeString(contents, encoding), mode: mode);
   }
 
   String get path => _path;
@@ skipping 15 matching lines @@
   final String _path;
 
   SendPort _fileService;
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._path);
 
   Future<RandomAccessFile> close() {
-    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     _ensureFileService();
     List request = new List(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).then((result) {
       if (result != -1) {
         _id = result;
@@ skipping 10 matching lines @@
     _checkNotClosed();
     var id = _close(_id);
     if (id == -1) {
       throw new FileIOException("Cannot close file '$_path'");
     }
     _id = id;
   }
 
   Future<int> readByte() {
     _ensureFileService();
-    Completer<int> completer = new Completer<int>();
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     List request = new List(2);
     request[0] = _READ_BYTE_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "readByte failed for file '$_path'");
       }
       return response;
     });
   }
 
   external static _readByte(int id);
 
   int readByteSync() {
     _checkNotClosed();
     var result = _readByte(_id);
     if (result is OSError) {
       throw new FileIOException("readByte failed for file '$_path'", result);
     }
     return result;
   }
 
   Future<List<int>> read(int bytes) {
     _ensureFileService();
-    Completer<List<int>> completer = new Completer<List<int>>();
     if (bytes is !int) {
-      // Complete asynchronously so the user has a chance to setup
-      // handlers without getting exceptions when registering the
-      // then handler.
-      Timer.run(() {
-        completer.completeError(new FileIOException(
-            "Invalid arguments to read for file '$_path'"));
-      });
-      return completer.future;
-    };
-    if (closed) return _completeWithClosedException(completer);
+      return new Future.error(new FileIOException(
+          "Invalid arguments to read for file '$_path'"));
+    }
+    if (closed) return _closedException();
     List request = new List(3);
     request[0] = _READ_REQUEST;
     request[1] = _id;
     request[2] = bytes;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "read failed for file '$_path'");
       }
       return response[1];
@@ skipping 17 matching lines @@
   }
 
   Future<int> readInto(List<int> buffer, [int start, int end]) {
     _ensureFileService();
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       return new Future.error(new FileIOException(
           "Invalid arguments to readInto for file '$_path'"));
     };
-    Completer<int> completer = new Completer<int>();
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     List request = new List(3);
     if (start == null) start = 0;
     if (end == null) end = buffer.length;
     request[0] = _READ_LIST_REQUEST;
     request[1] = _id;
     request[2] = end - start;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "readInto failed for file '$_path'");
@@ skipping 30 matching lines @@
     var result = _readInto(_id, buffer, start, end);
     if (result is OSError) {
       throw new FileIOException("readInto failed for file '$_path'",
                                 result);
     }
     return result;
   }
 
   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.
-      Timer.run(() {
-          completer.completeError(new FileIOException(
-              "Invalid argument to writeByte for file '$_path'"));
-      });
-      return completer.future;
+      return new Future.error(new FileIOException(
+          "Invalid argument to writeByte for file '$_path'"));
     }
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     List request = new List(3);
     request[0] = _WRITE_BYTE_REQUEST;
     request[1] = _id;
     request[2] = value;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "writeByte failed for file '$_path'");
       }
       return this;
@@ skipping 17 matching lines @@
   }
 
   Future<RandomAccessFile> writeFrom(List<int> buffer, [int start, int end]) {
     _ensureFileService();
     if ((buffer is !List && buffer is !ByteData) ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       return new Future.error(new FileIOException(
           "Invalid arguments to writeFrom for file '$_path'"));
     }
-    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
 
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
 
     _BufferAndStart result;
     try {
       result = _ensureFastAndSerializableBuffer(buffer, start, end);
     } catch (e) {
       return new Future.error(e);
     }
 
     List request = new List(5);
     request[0] = _WRITE_LIST_REQUEST;
@@ skipping 31 matching lines @@
                             bufferAndStart.start,
                             end - (start - bufferAndStart.start));
     if (result is OSError) {
       throw new FileIOException("writeFrom failed for file '$_path'", result);
     }
   }
 
   Future<RandomAccessFile> writeString(String string,
                                        {Encoding encoding: Encoding.UTF_8}) {
     if (encoding is! Encoding) {
-      var completer = new Completer();
-      Timer.run(() {
-        completer.completeError(new FileIOException(
-            "Invalid encoding in writeString: $encoding"));
-      });
-      return completer.future;
+      return new Future.error(new FileIOException(
+          "Invalid encoding in writeString: $encoding"));
     }
     var data = _encodeString(string, encoding);
     return writeFrom(data, 0, data.length);
   }
 
   void writeStringSync(String string, {Encoding encoding: Encoding.UTF_8}) {
     if (encoding is! Encoding) {
       throw new FileIOException(
           "Invalid encoding in writeStringSync: $encoding");
     }
     var data = _encodeString(string, encoding);
     writeFromSync(data, 0, data.length);
   }
 
   Future<int> position() {
     _ensureFileService();
-    Completer<int> completer = new Completer<int>();
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     List request = new List(2);
     request[0] = _POSITION_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "position failed for file '$_path'");
       }
       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 '$_path'", result);
     }
     return result;
   }
 
   Future<RandomAccessFile> setPosition(int position) {
     _ensureFileService();
-    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     List request = new List(3);
     request[0] = _SET_POSITION_REQUEST;
     request[1] = _id;
     request[2] = position;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "setPosition failed for file '$_path'");
       }
       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 '$_path'", result);
     }
   }
 
   Future<RandomAccessFile> truncate(int length) {
     _ensureFileService();
-    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     List request = new List(3);
     request[0] = _TRUNCATE_REQUEST;
     request[1] = _id;
     request[2] = length;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "truncate failed for file '$_path'");
       }
       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 '$_path'", result);
     }
   }
 
   Future<int> length() {
     _ensureFileService();
-    Completer<int> completer = new Completer<int>();
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     List request = new List(2);
     request[0] = _LENGTH_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "length failed for file '$_path'");
       }
       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 '$_path'", result);
     }
     return result;
   }
 
   Future<RandomAccessFile> flush() {
     _ensureFileService();
-    Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
-    if (closed) return _completeWithClosedException(completer);
+    if (closed) return _closedException();
     List request = new List(2);
     request[0] = _FLUSH_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "flush failed for file '$_path'");
       }
       return this;
     });
@@ skipping 18 matching lines @@
   }
 
   bool get closed => _id == 0;
 
   void _checkNotClosed() {
     if (closed) {
       throw new FileIOException("File closed '$_path'");
     }
   }
 
-  Future _completeWithClosedException(Completer completer) {
-    Timer.run(() {
-      completer.completeError(
-          new FileIOException("File closed '$_path'"));
-    });
-    return completer.future;
+  Future _closedException() {
+    return new Future.error(new FileIOException("File closed '$_path'"));
   }
 
   final String _path;
   int _id;
 
   SendPort _fileService;
 }