Add close to input stream and cleanup socket and streams

runtime/bin/file_impl.dart

 // Copyright (c) 2011, 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 implements FileInputStream {
+class _FileInputStream implements InputStream {
   _FileInputStream(File file) {
     _file = file.openSync();
     _length = _file.lengthSync();
     _checkScheduleCallbacks();
   }
 
   List<int> read([int len]) {
     if (_closed) return null;
     int bytesToRead = available();
     if (bytesToRead == 0) {
@@ skipping 21 matching lines @@
   int readInto(List<int> buffer, int offset, int len) {
     if (offset === null) offset = 0;
     if (len === null) len = buffer.length;
     if (offset < 0) throw new StreamException("Illegal offset $offset");
     if (len < 0) throw new StreamException("Illegal length $len");
     int result = _file.readListSync(buffer, offset, len);
     _checkScheduleCallbacks();
     return result;
   }
 
-  int available() {
-    return _length - _file.positionSync();
-  }
+  int available() => (_closing || _eof) ? 0 : _length - _file.positionSync();
 
   void pipe(OutputStream output, [bool close = true]) {
     _pipe(this, output, close: close);
   }
 
-  bool closed() => _eof;
+  bool get closed() => _eof;
 
   void close() {
+    _closing = true;
     _file.closeSync();
-    _closed = true;
   }
 
   void set dataHandler(void callback()) {
     _clientDataHandler = callback;
     _checkScheduleCallbacks();
   }
 
   void set closeHandler(void callback()) {
     _clientCloseHandler = callback;
   }
 
   void set errorHandler(void callback()) {
     // TODO(sgjesse): How to handle this?
   }
 
   void _checkScheduleCallbacks() {
-    // TODO(sgjesse): Find a better way of scheduling callbacks from
-    // the event loop.
     void issueDataCallback(Timer timer) {
       _scheduledDataCallback = null;
       if (_clientDataHandler !== null) {
         _clientDataHandler();
         _checkScheduleCallbacks();
       }
     }
 
     void issueCloseCallback(Timer timer) {
       _scheduledCloseCallback = null;
       if (!_closed) {
         if (_clientCloseHandler !== null) _clientCloseHandler();
         _closed = true;
       }
     }
 
     // Schedule data callback if there is more data to read. Schedule
     // close callback once when all data has been read. Only schedule
     // a new callback if the previous one has actually been called.
     if (!_closed) {
       if (available() > 0) {
         if (_scheduledDataCallback == null) {
           _scheduledDataCallback = new Timer(issueDataCallback, 0);
         }
       } else if (!_eof) {
+        close();
         if (_scheduledCloseCallback == null) {
           _scheduledCloseCallback = new Timer(issueCloseCallback, 0);
-          _eof = true;
         }
+        _eof = true;
       }
     }
   }
 
   RandomAccessFile _file;
   int _length;
   bool _eof = false;
+  bool _closing = false;
   bool _closed = false;
   Timer _scheduledDataCallback;
   Timer _scheduledCloseCallback;
   Function _clientDataHandler;
   Function _clientCloseHandler;
 }
 
 
-class _FileOutputStream implements FileOutputStream {
+class _FileOutputStream implements OutputStream {
   _FileOutputStream(File file) {
     _file = file.openSync(true);
   }
 
   bool write(List<int> buffer, [bool copyBuffer = false]) {
     return _write(buffer, 0, buffer.length);
   }
 
   bool writeFrom(List<int> buffer, [int offset = 0, int len]) {
     return _write(
         buffer, offset, (len == null) ? buffer.length - offset : len);
   }
 
-  void end() {
-    _file.closeSync();
-  }
-
   void close() {
     _file.closeSync();
   }
 
   void set noPendingWriteHandler(void callback()) {
     // TODO(sgjesse): How to handle this?
   }
 
   void set closeHandler(void callback()) {
     // TODO(sgjesse): How to handle this?
@@ skipping 973 matching lines @@
   var _readByteHandler;
   var _readListHandler;
   var _noPendingWriteHandler;
   var _positionHandler;
   var _setPositionHandler;
   var _truncateHandler;
   var _lengthHandler;
   var _flushHandler;
   var _errorHandler;
 }