Remove AsyncError with Expando.

runtime/bin/socket_patch.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.
 
 patch class RawServerSocket  {
   /* patch */ static Future<RawServerSocket> bind([String address = "127.0.0.1",
                                                    int port = 0,
                                                    int backlog = 0]) {
     return _RawServerSocket.bind(address, port, backlog);
   }
@@ skipping 423 matching lines @@
     _controller = new StreamController(
         onSubscriptionStateChange: _onSubscriptionStateChange,
         onPauseStateChange: _onPauseStateChange);
     _socket.closeFuture.then((_) => _controller.close());
     _socket.setHandlers(
       read: () {
         var socket = _socket.accept();
         if (socket != null) _controller.add(new _RawSocket(socket));
       },
       error: (e) {
-        _controller.addError(new AsyncError(e));
+        _controller.addError(e);
         _controller.close();
       }
     );
   }
 
   StreamSubscription<RawSocket> listen(void onData(RawSocket event),
-                                       {void onError(AsyncError error),
+                                       {void onError(Object error),
                                         void onDone(),
                                         bool unsubscribeOnError}) {
     return _controller.stream.listen(
         onData,
         onError: onError,
         onDone: onDone,
         unsubscribeOnError: unsubscribeOnError);
   }
 
   int get port => _socket.port;
@@ skipping 45 matching lines @@
     _socket.setHandlers(
       read: () => _controller.add(RawSocketEvent.READ),
       write: () {
         // The write event handler is automatically disabled by the
         // event handler when it fires.
         _writeEventsEnabled = false;
         _controller.add(RawSocketEvent.WRITE);
       },
       closed: () => _controller.add(RawSocketEvent.READ_CLOSED),
       error: (e) {
-        _controller.addError(new AsyncError(e));
+        _controller.addError(e);
         close();
       }
     );
   }
 
   factory _RawSocket._writePipe(int fd) {
     var native = new _NativeSocket.pipe();
     native.isClosedRead = true;
     if (fd != null) _getStdioHandle(native, fd);
     return new _RawSocket(native);
   }
 
   factory _RawSocket._readPipe(int fd) {
     var native = new _NativeSocket.pipe();
     native.isClosedWrite = true;
     if (fd != null) _getStdioHandle(native, fd);
     return new _RawSocket(native);
   }
 
   StreamSubscription<RawSocketEvent> listen(void onData(RawSocketEvent event),
-                                            {void onError(AsyncError error),
+                                            {void onError(Object error),
                                              void onDone(),
                                              bool unsubscribeOnError}) {
     return _controller.stream.listen(
         onData,
         onError: onError,
         onDone: onDone,
         unsubscribeOnError: unsubscribeOnError);
   }
 
   int available() => _socket.available();
@@ skipping 73 matching lines @@
   static Future<_ServerSocket> bind(String address,
                                     int port,
                                     int backlog) {
     return _RawServerSocket.bind(address, port, backlog)
         .then((socket) => new _ServerSocket(socket));
   }
 
   _ServerSocket(this._socket);
 
   StreamSubscription<Socket> listen(void onData(Socket event),
-                                    {void onError(AsyncError error),
+                                    {void onError(error),
                                      void onDone(),
                                      bool unsubscribeOnError}) {
     return _socket.map((rawSocket) => new _Socket(rawSocket)).listen(
         onData,
         onError: onError,
         onDone: onDone,
         unsubscribeOnError: unsubscribeOnError);
   }
 
   int get port => _socket.port;
@@ skipping 134 matching lines @@
     return new _Socket(new _RawSocket._writePipe(fd));
   }
 
   factory _Socket._readPipe([int fd]) {
     return new _Socket(new _RawSocket._readPipe(fd));
   }
 
   _NativeSocket get _nativeSocket => _raw._socket;
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
-                                       {void onError(AsyncError error),
+                                       {void onError(error),
                                         void onDone(),
                                         bool unsubscribeOnError}) {
     return _controller.stream.listen(
         onData,
         onError: onError,
         onDone: onDone,
         unsubscribeOnError: unsubscribeOnError);
   }
 
   Encoding get encoding => _sink.encoding;
@@ skipping 143 matching lines @@
     _raw.onBadCertificate = callback;
   }
 
   X509Certificate get peerCertificate {
     if (_raw == null) {
      throw new StateError("peerCertificate called on destroyed SecureSocket");
     }
     return _raw.peerCertificate;
   }
 }