Adapt streams for additional stackTrace argument.

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 20 matching lines @@
 
   _FileStream(String this._path, this._position, this._end) {
     _setupController();
   }
 
   _FileStream.forStdin() : _position = 0 {
     _setupController();
   }
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
-                                       {void onError(error),
+                                       {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
     return _controller.stream.listen(onData,
                                      onError: onError,
                                      onDone: onDone,
                                      cancelOnError: cancelOnError);
   }
 
   void _setupController() {
     _controller = new StreamController<List<int>>(sync: true,
@@ skipping 132 matching lines @@
             openedFile.writeFrom(d, 0, d.length)
               .then((_) => _subscription.resume())
               .catchError((e) {
                 openedFile.close();
                 completer.completeError(e);
               });
           },
           onDone: () {
             completer.complete(_file);
           },
-          onError: (e) {
+          onError: (e, [StackTrace stackTrace]) {
             openedFile.close();
-            completer.completeError(e);
+            completer.completeError(e, stackTrace);
           },
           cancelOnError: true);
       })
       .catchError((e) {
         completer.completeError(e);
       });
     return completer.future;
   }
 
   Future<File> close() {
@@ skipping 204 matching lines @@
   }
 
   Future<List<int>> readAsBytes() {
     Completer<List<int>> completer = new Completer<List<int>>();
     var builder = new BytesBuilder();
     openRead().listen(
       (d) => builder.add(d),
       onDone: () {
         completer.complete(builder.takeBytes());
       },
-      onError: (e) {
-        completer.completeError(e);
+      onError: (e, StackTrace stackTrace) {
+        completer.completeError(e, stackTrace);
       },
       cancelOnError: true);
     return completer.future;
   }
 
   List<int> readAsBytesSync() {
     var opened = openSync();
     var builder = new BytesBuilder();
     var data;
     while ((data = opened.readSync(_BLOCK_SIZE)).length > 0) {
@@ skipping 437 matching lines @@
 
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileException("An async operation is currently pending", path);
     }
     if (closed) {
       throw new FileException("File closed", path);
     }
   }
 }