Refactor Future constructors.

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 45 matching lines @@
         });
   }
 
   Future _closeFile() {
     Future closeFuture;
     if (_openedFile != null) {
       Future closeFuture = _openedFile.close();
       _openedFile = null;
       return closeFuture;
     } else {
-      return new Future.immediate(null);
+      return new Future.value();
     }
   }
 
   void _readBlock() {
     // Don't start a new read if one is already in progress.
     if (_readInProgress) return;
     _readInProgress = true;
     _openedFile.length()
       .then((length) {
         if (_position >= length) {
@@ skipping 27 matching lines @@
           _unsubscribed = true;
         }
       });
   }
 
   void _start() {
     Future<RandomAccessFile> openFuture;
     if (_path != null) {
       openFuture = new File(_path).open(mode: FileMode.READ);
     } else {
-      openFuture = new Future.immediate(_File._openStdioSync(0));
+      openFuture = new Future.value(_File._openStdioSync(0));
     }
     openFuture
       .then((RandomAccessFile opened) {
         _openedFile = opened;
         _readBlock();
       })
       .catchError((e) {
         _controller.addError(e);
         _controller.close();
       });
@@ skipping 14 matching lines @@
   File _file;
   Future<RandomAccessFile> _openFuture;
   StreamSubscription _subscription;
 
   _FileStreamConsumer(File this._file, FileMode mode) {
     _openFuture = _file.open(mode: mode);
   }
 
   _FileStreamConsumer.fromStdio(int fd) {
     assert(1 <= fd && fd <= 2);
-    _openFuture = new Future.immediate(_File._openStdioSync(fd));
+    _openFuture = new Future.value(_File._openStdioSync(fd));
   }
 
   Future<File> addStream(Stream<List<int>> stream) {
     Completer<File> completer = new Completer<File>();
     _openFuture
       .then((openedFile) {
         _subscription = stream.listen(
           (d) {
             _subscription.pause();
             openedFile.writeFrom(d, 0, d.length)
@@ skipping 378 matching lines @@
   }
 
   Future<File> writeAsBytes(List<int> bytes,
                             {FileMode mode: FileMode.WRITE}) {
     try {
       IOSink sink = openWrite(mode: mode);
       sink.add(bytes);
       sink.close();
       return sink.done.then((_) => this);;
     } catch (e) {
-      return new Future.immediateError(e);
+      return new Future.error(e);
     }
   }
 
   void writeAsBytesSync(List<int> bytes, {FileMode mode: FileMode.WRITE}) {
     RandomAccessFile opened = openSync(mode: mode);
     opened.writeFromSync(bytes, 0, bytes.length);
     opened.closeSync();
   }
 
   Future<File> writeAsString(String contents,
@@ skipping 138 matching lines @@
                                 result);
     }
     return result;
   }
 
   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.immediateError(new FileIOException(
+      return new Future.error(new FileIOException(
           "Invalid arguments to readInto for file '$_path'"));
     };
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
     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;
@@ skipping 80 matching lines @@
                                 result);
     }
     return result;
   }
 
   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.immediateError(new FileIOException(
+      return new Future.error(new FileIOException(
           "Invalid arguments to writeFrom for file '$_path'"));
     }
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
 
     if (closed) return _completeWithClosedException(completer);
 
     _BufferAndStart result;
     try {
       result = _ensureFastAndSerializableBuffer(buffer, start, end);
     } catch (e) {
-      return new Future.immediateError(e);
+      return new Future.error(e);
     }
 
     List request = new List(5);
     request[0] = _WRITE_LIST_REQUEST;
     request[1] = _id;
     request[2] = result.buffer;
     request[3] = result.start;
     request[4] = end - (start - result.start);
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
@@ skipping 208 matching lines @@
           new FileIOException("File closed '$_path'"));
     });
     return completer.future;
   }
 
   final String _path;
   int _id;
 
   SendPort _fileService;
 }