Add both sync and async methods for getting streams for a File

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(File file) {
-    _file = file.openSync();
-    _length = _file.lengthSync();
+  _FileInputStream(RandomAccessFile this._file, int this._length) {
     _streamMarkedClosed = true;
     _checkScheduleCallbacks();
   }
 
   _FileInputStream.fromStdio(int fd) {
     assert(fd == 0);
     _file = _File._openStdioSync(fd);
     _length = _file.lengthSync();
     _streamMarkedClosed = true;
     _checkScheduleCallbacks();
@@ skipping 31 matching lines @@
     _closed = true;
   }
 
   RandomAccessFile _file;
   int _length;
   bool _closed = false;
 }
 
 
 class _FileOutputStream implements OutputStream {
-  _FileOutputStream(File file, FileMode mode) {
-    _file = file.openSync(mode);
-  }
+  _FileOutputStream(this._file);
 
   _FileOutputStream.fromStdio(int fd) {
     assert(1 <= fd && fd <= 2);
     _file = _File._openStdioSync(fd);
   }
 
   bool write(List<int> buffer, [bool copyBuffer = false]) {
-    return _write(buffer, 0, buffer.length);
+    bool result = _write(buffer, 0, buffer.length);
+    if (result) {
+      _checkScheduleCallbacks();
+    }
+    return result;
   }
 
   bool writeFrom(List<int> buffer, [int offset = 0, int len]) {
-    return _write(
+    bool result = _write(
         buffer, offset, (len == null) ? buffer.length - offset : len);
+    if (result) {
+      _checkScheduleCallbacks();
+    }
+    return result;
   }
 
   void close() {
-    _file.closeSync();
+    if (_scheduledNoPendingWriteCallback != null) {
+      _scheduledNoPendingWriteCallback.cancel();
+    }
+    if (!_streamMarkedClosed) {
+      _file.closeSync();
+      _streamMarkedClosed = true;
+      _checkScheduleCallbacks();
+    }
   }
 
   void set noPendingWriteHandler(void callback()) {
-    // TODO(sgjesse): How to handle this?
+    _noPendingWriteHandler = callback;
+    _checkScheduleCallbacks();
   }
 
   void set closeHandler(void callback()) {
-    // TODO(sgjesse): How to handle this?
+    _closeHandler = callback;
+    _checkScheduleCallbacks();
   }
 
   void set errorHandler(void callback()) {
     // TODO(sgjesse): How to handle this?
   }
 
   bool _write(List<int> buffer, int offset, int len) {
     int bytesWritten = _file.writeListSync(buffer, offset, len);
     if (bytesWritten == len) {
       return true;
     } else {
       throw "FileOutputStream: write error";
     }
   }
 
+  void _checkScheduleCallbacks() {
+    void issueNoPendingWriteCallback(Timer timer) {
+      _scheduledNoPendingWriteCallback = null;
+      if (_noPendingWriteHandler !== null) {
+        _noPendingWriteHandler();
+        _checkScheduleCallbacks();
+      }
+    }
+
+    void issueCloseCallback(Timer timer) {
+      if (_closeHandler !== null) _closeHandler();
+    }
+
+    // Schedule no pending write callbacks if the stream is not yet
+    // closed and close callback if it is closing.
+    if (!_closeCallbackCalled) {
+      if (_scheduledNoPendingWriteCallback == null) {
+        _scheduledNoPendingWriteCallback =
+            new Timer(issueNoPendingWriteCallback, 0);
+      }
+      if (_streamMarkedClosed && _scheduledCloseCallback == null) {
+        _scheduledCloseCallback = new Timer(issueCloseCallback, 0);
+      }
+    }
+  }
+
   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;
+
+  Timer _scheduledNoPendingWriteCallback;
+  Timer _scheduledCloseCallback;
+  Function _noPendingWriteHandler;
+  Function _closeHandler;
 }
 
 
 class _FileOperation {
   abstract void execute(ReceivePort port);
 
   void set replyPort(SendPort port) {
     _replyPort = port;
   }
 
@@ skipping 546 matching lines @@
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     String result = _FileUtils.checkedFullPath(_name);
     if (result == null) {
       throw new FileIOException("fullPath failed");
     }
     return result;
   }
 
-  InputStream openInputStream() => new _FileInputStream(this);
+  void openInputStream() {
+    // Create a new file object to handle the opening of the file for
+    // creating an input stream. Currently the file input stream uses
+    // synchronous calls on the opened file so we need to open it
+    // synchronously.
+    File file = new File(this._name);
+    file.errorHandler = (String error) {
+      if (_errorHandler != null) _errorHandler(error);
+    };
+    RandomAccessFile openedFile = file.openSync();
+    InputStream stream =
+        new _FileInputStream(openedFile, openedFile.lengthSync());
+    new Timer(
+        (Timer ignore) {
+          if (_inputStreamHandler != null) _inputStreamHandler(stream);
+        }, 0);
+  }
 
-  OutputStream openOutputStream([FileMode mode = FileMode.WRITE]) {
+  InputStream openInputStreamSync() {
+    if (_asyncUsed) {
+      throw new FileIOException(
+          "Mixed use of synchronous and asynchronous API");
+    }
+    RandomAccessFile openedFile = openSync();
+    return new _FileInputStream(openedFile, openedFile.lengthSync());
+  }
+
+  void 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(this, mode);
+    // Create a new file object to handle the opening of the file for
+    // creating an input stream. Currently the file input stream uses
+    // synchronous calls on the opened file so we need to open it
+    // synchronously.
+    File file = new File(this._name);
+    file.errorHandler = (String error) {
+      if (_errorHandler != null) _errorHandler(error);
+    };
+    RandomAccessFile openedFile = file.openSync(mode);
+    OutputStream stream = new _FileOutputStream(openedFile);
+    new Timer(
+        (Timer ignore) {
+          if (_outputStreamHandler != null) _outputStreamHandler(stream);
+        }, 0);
+  }
+
+  OutputStream openOutputStreamSync([FileMode mode = FileMode.WRITE]) {
+    if (_asyncUsed) {
+      throw new FileIOException(
+          "Mixed use of synchronous and asynchronous API");
+    }
+    if (mode != FileMode.WRITE &&
+        mode != FileMode.APPEND) {
+      throw new FileIOException(
+          "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
+    }
+    RandomAccessFile openedFile = openSync(mode);
+    return new _FileOutputStream(openedFile);
   }
 
   String get name() => _name;
 
   void set existsHandler(void handler(bool exists)) {
     _existsHandler = handler;
   }
 
   void set createHandler(void handler()) {
     _createHandler = handler;
   }
 
   void set deleteHandler(void handler()) {
     _deleteHandler = handler;
   }
 
   void set openHandler(void handler(RandomAccessFile file)) {
     _openHandler = handler;
   }
 
+  void set inputStreamHandler(void handler(InputStream stream)) {
+    _inputStreamHandler = handler;
+  }
+
+  void set outputStreamHandler(void handler(OutputStream stream)) {
+    _outputStreamHandler = handler;
+  }
+
   void set fullPathHandler(void handler(String)) {
     _fullPathHandler = handler;
   }
 
   void set errorHandler(void handler(String error)) {
     _errorHandler = handler;
   }
 
   String _name;
   bool _asyncUsed;
 
   _FileOperationScheduler _scheduler;
 
-  var _existsHandler;
-  var _createHandler;
-  var _deleteHandler;
-  var _openHandler;
-  var _fullPathHandler;
-  var _errorHandler;
+  Function _existsHandler;
+  Function _createHandler;
+  Function _deleteHandler;
+  Function _openHandler;
+  Function _inputStreamHandler;
+  Function _outputStreamHandler;
+  Function _fullPathHandler;
+  Function _errorHandler;
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._name)
     : _scheduler = new _FileOperationScheduler(),
       _asyncUsed = false;
 
   void close() {
     _asyncUsed = true;
@@ skipping 380 matching lines @@
   void set flushHandler(void handler()) {
     _flushHandler = handler;
   }
 
   String _name;
   int _id;
   bool _asyncUsed;
 
   _FileOperationScheduler _scheduler;
 
-  var _closeHandler;
-  var _readByteHandler;
-  var _readListHandler;
-  var _noPendingWriteHandler;
-  var _positionHandler;
-  var _setPositionHandler;
-  var _truncateHandler;
-  var _lengthHandler;
-  var _flushHandler;
-  var _errorHandler;
+  Function _closeHandler;
+  Function _readByteHandler;
+  Function _readListHandler;
+  Function _noPendingWriteHandler;
+  Function _positionHandler;
+  Function _setPositionHandler;
+  Function _truncateHandler;
+  Function _lengthHandler;
+  Function _flushHandler;
+  Function _errorHandler;
 }