Remove AsyncError with Expando.

sdk/lib/io/http_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;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 17 matching lines @@
   // the length of the massage body is not known due to transfer
   // codings.
   int get transferLength => _transferLength;
 
   _HttpIncoming(_HttpHeaders this.headers,
                 int this._transferLength,
                 Stream<List<int>> this._stream) {
   }
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
-                                       {void onError(AsyncError error),
+                                       {void onError(error),
                                         void onDone(),
                                         bool cancelOnError}) {
     return _stream.listen(onData,
                           onError: onError,
                           onDone: onDone,
                           cancelOnError: cancelOnError);
   }
 
   // Is completed once all data have been received.
   Future get dataDone => _dataCompleter.future;
@@ skipping 50 matching lines @@
         _session = _httpServer._sessionManager.getSession(sessionId);
         if (_session != null) {
           _session._markSeen();
           break;
         }
       }
     }
   }
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
-                                       {void onError(AsyncError error),
+                                       {void onError(error),
                                         void onDone(),
                                         bool cancelOnError}) {
     return _incoming.listen(onData,
                             onError: onError,
                             onDone: onDone,
                             cancelOnError: cancelOnError);
   }
 
   Map<String, String> get queryParameters {
     if (_queryParameters == null) {
@@ skipping 104 matching lines @@
         .then((request) {
           request._responseRedirects.addAll(this.redirects);
           request._responseRedirects.add(new _RedirectInfo(statusCode,
                                                            method,
                                                            url));
           return request.close();
         });
   }
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
-                                       {void onError(AsyncError error),
+                                       {void onError(error),
                                         void onDone(),
                                         bool cancelOnError}) {
     var stream = _incoming;
     if (headers.value(HttpHeaders.CONTENT_ENCODING) == "gzip") {
       stream = stream.transform(new ZLibInflater());
     }
     return stream.listen(onData,
                          onError: onError,
                          onDone: onDone,
                          cancelOnError: cancelOnError);
@@ skipping 190 matching lines @@
 
   void writeCharCode(int charCode) {
     _dataSink.writeCharCode(charCode);
   }
 
   void add(List<int> data) {
     if (data.length == 0) return;
     _dataSink.add(data);
   }
 
-  void addError(AsyncError error) {
+  void addError(error) {
     _dataSink.addError(error);
   }
 
   Future<T> addStream(Stream<List<int>> stream) {
     return _dataSink.addStream(stream);
   }
 
   Future close() {
     return _dataSink.close();
   }
@@ skipping 416 matching lines @@
     } else {
       future = new Future<HttpClientResponse>.immediate(response);
     }
     future.then(
         (v) => _responseCompleter.complete(v),
         onError: (e) {
           _responseCompleter.completeError(e);
         });
   }
 
-  void _onError(AsyncError error) {
+  void _onError(error) {
     _responseCompleter.completeError(error);
   }
 
   void _writeHeader() {
     var buffer = new _BufferList();
     writeSP() => buffer.add(const [_CharCode.SP]);
     writeCRLF() => buffer.add(const [_CharCode.CR, _CharCode.LF]);
 
     buffer.add(method.codeUnits);
     writeSP();
@@ skipping 78 matching lines @@
 class _ContentLengthValidator
     extends StreamEventTransformer<List<int>, List<int>> {
   final int expectedContentLength;
   int _bytesWritten = 0;
 
   _ContentLengthValidator(int this.expectedContentLength);
 
   void handleData(List<int> data, EventSink<List<int>> sink) {
     _bytesWritten += data.length;
     if (_bytesWritten > expectedContentLength) {
-      sink.addError(new AsyncError(new HttpException(
+      sink.addError(new HttpException(
           "Content size exceeds specified contentLength. "
           "$_bytesWritten bytes written while expected "
           "$expectedContentLength. "
-          "[${new String.fromCharCodes(data)}]")));
+          "[${new String.fromCharCodes(data)}]"));
       sink.close();
     } else {
       sink.add(data);
     }
   }
 
   void handleDone(EventSink<List<int>> sink) {
     if (_bytesWritten < expectedContentLength) {
-      sink.addError(new AsyncError(new HttpException(
+      sink.addError(new HttpException(
           "Content size below specified contentLength. "
           " $_bytesWritten bytes written while expected "
-          "$expectedContentLength.")));
+          "$expectedContentLength."));
     }
     sink.close();
   }
 }
 
 
 // Extends StreamConsumer as this is an internal type, only used to pipe to.
 class _HttpOutgoing implements StreamConsumer<List<int>> {
   final Completer _doneCompleter = new Completer();
   final StreamConsumer _consumer;
@@ skipping 371 matching lines @@
                                          port,
                                          sendClientCertificate: true)
                   : Socket.connect(host, port))
         .then((socket) {
           socket.setOption(SocketOption.TCP_NODELAY, true);
           var connection = new _HttpClientConnection(key, socket, this);
           _activeConnections.add(connection);
           return new _ConnnectionInfo(connection, proxy);
         }, onError: (error) {
           // Continue with next proxy.
-          return connect(error.error);
+          return connect(error);
         });
     }
     return connect(new HttpException("No proxies given"));
   }
 
   _Credentials _findCredentials(Uri url, [_AuthenticationScheme scheme]) {
     // Look for credentials.
     _Credentials cr =
         _credentials.fold(null, (_Credentials prev, _Credentials value) {
           if (value.applies(url, scheme)) {
@@ skipping 187 matching lines @@
           return new _HttpServer._(socket, true);
         });
   }
 
   _HttpServer._(this._serverSocket, this._closeServer);
 
   _HttpServer.listenOn(ServerSocket this._serverSocket)
       : _closeServer = false;
 
   StreamSubscription<HttpRequest> listen(void onData(HttpRequest event),
-                                         {void onError(AsyncError error),
+                                         {void onError(error),
                                          void onDone(),
                                          bool cancelOnError}) {
     _serverSocket.listen(
         (Socket socket) {
           socket.setOption(SocketOption.TCP_NODELAY, true);
           // Accept the client connection.
           _HttpConnection connection = new _HttpConnection(socket, this);
           _connections.add(connection);
         },
         onError: _controller.addError,
@@ skipping 25 matching lines @@
   }
 
   set sessionTimeout(int timeout) {
     _sessionManager.sessionTimeout = timeout;
   }
 
   void _handleRequest(HttpRequest request) {
     _controller.add(request);
   }
 
-  void _handleError(AsyncError error) {
+  void _handleError(error) {
     if (!closed) _controller.addError(error);
   }
 
   void _connectionClosed(_HttpConnection connection) {
     _connections.remove(connection);
   }
 
   _HttpSessionManager get _sessionManager {
     // Lazy init.
     if (_sessionManagerInstance == null) {
@@ skipping 136 matching lines @@
 }
 
 
 class _DetachedSocket extends Stream<List<int>> implements Socket {
   final Stream<List<int>> _incoming;
   final Socket _socket;
 
   _DetachedSocket(this._socket, this._incoming);
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
-                                       {void onError(AsyncError error),
+                                       {void onError(error),
                                         void onDone(),
                                         bool cancelOnError}) {
     return _incoming.listen(onData,
                             onError: onError,
                             onDone: onDone,
                             cancelOnError: cancelOnError);
   }
 
   Encoding get encoding => _socket.encoding;
 
   void set encoding(Encoding value) {
     _socket.encoding = value;
   }
 
   void write(Object obj) => _socket.write(obj);
 
   void writeln([Object obj = ""]) => _socket.writeln(obj);
 
   void writeCharCode(int charCode) => _socket.writeCharCode(charCode);
 
   void writeAll(Iterable objects, [String separator = ""]) {
     _socket.writeAll(objects, separator);
   }
 
   void add(List<int> bytes) => _socket.add(bytes);
 
-  void addError(AsyncError error) => _socket.addError(error);
+  void addError(error) => _socket.addError(error);
 
   Future<Socket> addStream(Stream<List<int>> stream) {
     return _socket.addStream(stream);
   }
 
   void destroy() => _socket.destroy();
 
   Future close() => _socket.close();
 
   Future<Socket> get done => _socket.done;
@@ skipping 150 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }