Revert "Add new InternetAddress class with a static lookup function (including IPv6 results)."

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);
   }
 }
 
 
 patch class RawSocket {
-  /* patch */ static Future<RawSocket> connect(host, int port) {
+  /* patch */ static Future<RawSocket> connect(String host, int port) {
     return _RawSocket.connect(host, port);
   }
 }
 
 
-patch class InternetAddress {
-  /* patch */ static Future<List<InternetAddress>> lookup(
-      String host, {InternetAddressType type: InternetAddressType.ANY}) {
-    return _NativeSocket.lookup(host, type: type);
-  }
-}
-
-class _InternetAddress implements InternetAddress {
-  final InternetAddressType type;
-  final String address;
-  final String host;
-  final Uint8List _sockaddr_storage;
-
-  _InternetAddress(InternetAddressType this.type,
-                   String this.address,
-                   String this.host,
-                   List<int> this._sockaddr_storage);
-
-  String toString() {
-    return "InternetAddress('$address', ${type.name})";
-  }
-}
-
-
 // The _NativeSocket class encapsulates an OS socket.
 class _NativeSocket extends NativeFieldWrapperClass1 {
   // Bit flags used when communicating between the eventhandler and
   // dart code. The EVENT flags are used to indicate events of
   // interest when sending a message from dart code to the
   // eventhandler. When receiving a message from the eventhandler the
   // EVENT flags indicate the events that actually happened. The
   // COMMAND flags are used to send commands from dart to the
   // eventhandler. COMMAND flags are never received from the
   // eventhandler. Additional flags are used to communicate other
@@ skipping 36 matching lines @@
 
   // Indicates if native interrupts can be activated.
   bool canActivateEvents = true;
 
   // The type flags for this socket.
   final int typeFlags;
 
   // Holds the port of the socket, null if not known.
   int localPort;
 
-  // Holds the address used to connect or bind the socket.
-  InternetAddress address;
+  // Holds the host or address used to connect or bind the socket.
+  String localHost;
 
   // Native port for socket services.
   static SendPort socketService;
 
-  static Future<List<InternetAddress>> lookup(
-      String host, {InternetAddressType type: InternetAddressType.ANY}) {
+  static Future<_NativeSocket> connect(String host, int port) {
+    var completer = new Completer();
     ensureSocketService();
-    return socketService.call([HOST_NAME_LOOKUP, host, type._value])
-        .then((response) {
-          if (isErrorResponse(response)) {
-            throw createError(response, "Failed host name lookup");
-          } else {
-            return response.skip(1).map((result) {
-              var type = new InternetAddressType._from(result[0]);
-              return new _InternetAddress(type, result[1], host, result[2]);
-            }).toList();
-          }
-        });
-  }
-
-  static Future<_NativeSocket> connect(host, int port) {
-    return new Future.value(host)
-        .then((host) {
-          if (host is _InternetAddress) return host;
-          return lookup(host)
-              .then((list) {
-                if (list.length == 0) {
-                  throw createError(response, "Failed host name lookup");
-                }
-                return list[0];
-              });
-        })
-        .then((address) {
-          ensureSocketService();
-          var socket = new _NativeSocket.normal();
-          socket.address = address;
-          var result = socket.nativeCreateConnect(
-              address._sockaddr_storage, port);
-          if (result is OSError) {
-            throw createError(result, "Connection failed");
-          } else {
-            var completer = new Completer();
-            // Setup handlers for receiving the first write event which
-            // indicate that the socket is fully connected.
-            socket.setHandlers(
-                write: () {
-                  socket.setListening(read: false, write: false);
-                  completer.complete(socket);
-                },
-                error: (e) {
-                  socket.close();
-                  completer.completeError(createError(e, "Connection failed"));
-                }
-            );
-            socket.setListening(read: false, write: true);
-            return completer.future;
-          }
-        });
+    socketService.call([HOST_NAME_LOOKUP, host]).then((response) {
+      if (isErrorResponse(response)) {
+        completer.completeError(
+            createError(response, "Failed host name lookup"));
+      } else {
+        var socket = new _NativeSocket.normal();
+        socket.localHost = host;
+        var result = socket.nativeCreateConnect(response, port);
+        if (result is OSError) {
+          completer.completeError(createError(result, "Connection failed"));
+        } else {
+          // Setup handlers for receiving the first write event which
+          // indicate that the socket is fully connected.
+          socket.setHandlers(
+              write: () {
+                socket.setListening(read: false, write: false);
+                completer.complete(socket);
+              },
+              error: (e) {
+                socket.close();
+                completer.completeError(createError(e, "Connection failed"));
+              }
+          );
+          socket.setListening(read: false, write: true);
+        }
+      }
+    });
+    return completer.future;
   }
 
   static Future<_NativeSocket> bind(String address,
                                     int port,
                                     int backlog) {
-    return lookup(address)
-        .then((list) {
-          if (list.length == 0) {
-            throw createError(response, "Failed host name lookup");
-          }
-          return list[0];
-        })
-        .then((address) {
-          var socket = new _NativeSocket.listen();
-          socket.address = address;
-          var result = socket.nativeCreateBindListen(address._sockaddr_storage,
-                                                     port,
-                                                     backlog);
-          if (result is OSError) {
-            throw new SocketIOException(
-                "Failed to create server socket", result);
-          }
-          if (port != 0) socket.localPort = port;
-          return socket;
-        });
+    var socket = new _NativeSocket.listen();
+    socket.localHost = address;
+    var result = socket.nativeCreateBindListen(address, port, backlog);
+    if (result is OSError) {
+      return new Future.error(
+          new SocketIOException("Failed to create server socket", result));
+    }
+    if (port != 0) socket.localPort = port;
+    return new Future.value(socket);
   }
 
   _NativeSocket.normal() : typeFlags = TYPE_NORMAL_SOCKET {
     eventHandlers = new List(EVENT_COUNT + 1);
     _EventHandler._start();
   }
 
   _NativeSocket.listen() : typeFlags = TYPE_LISTENING_SOCKET {
     eventHandlers = new List(EVENT_COUNT + 1);
     _EventHandler._start();
@@ skipping 49 matching lines @@
     if (result is OSError) {
       reportError(result, "Write failed");
       result = 0;
     }
     return result;
   }
 
   _NativeSocket accept() {
     var socket = new _NativeSocket.normal();
     if (nativeAccept(socket) != true) return null;
-    socket.localPort = localPort;
-    socket.address = address;
     return socket;
   }
 
   int get port {
     if (localPort != null) return localPort;
     return localPort = nativeGetPort();
   }
 
   int get remotePort {
     return nativeGetRemotePeer()[1];
   }
 
+  String get host => localHost;
+
   String get remoteHost {
     return nativeGetRemotePeer()[0];
   }
 
   // Multiplexes socket events to the socket handlers.
   void multiplex(int events) {
     canActivateEvents = false;
     for (int i = FIRST_EVENT; i <= LAST_EVENT; i++) {
       if (((events & (1 << i)) != 0)) {
         if (i == CLOSED_EVENT &&
@@ skipping 181 matching lines @@
   bool setOption(SocketOption option, bool enabled) {
     if (option is! SocketOption) throw new ArgumentError(options);
     if (enabled is! bool) throw new ArgumentError(enabled);
     return nativeSetOption(option._value, enabled);
   }
 
   nativeAvailable() native "Socket_Available";
   nativeRead(int len) native "Socket_Read";
   nativeWrite(List<int> buffer, int offset, int bytes)
       native "Socket_WriteList";
-  nativeCreateConnect(List<int> addr,
-                      int port) native "Socket_CreateConnect";
-  nativeCreateBindListen(List<int> addr, int port, int backlog)
+  nativeCreateConnect(String host, int port) native "Socket_CreateConnect";
+  nativeCreateBindListen(String address, int port, int backlog)
       native "ServerSocket_CreateBindListen";
   nativeAccept(_NativeSocket socket) native "ServerSocket_Accept";
   int nativeGetPort() native "Socket_GetPort";
   List nativeGetRemotePeer() native "Socket_GetRemotePeer";
   OSError nativeGetError() native "Socket_GetError";
   bool nativeSetOption(int option, bool enabled) native "Socket_SetOption";
 
   static SendPort newServicePort() native "Socket_NewServicePort";
 }
 
@@ skipping 72 matching lines @@
 }
 
 
 class _RawSocket extends Stream<RawSocketEvent>
                  implements RawSocket {
   final _NativeSocket _socket;
   StreamController<RawSocketEvent> _controller;
   bool _readEventsEnabled = true;
   bool _writeEventsEnabled = true;
 
-  static Future<RawSocket> connect(host, int port) {
+  static Future<RawSocket> connect(String host, int port) {
     return _NativeSocket.connect(host, port)
         .then((socket) => new _RawSocket(socket));
   }
 
   _RawSocket(this._socket) {
     _controller = new StreamController(
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
@@ skipping 47 matching lines @@
       _socket.write(buffer, offset, count);
 
   void close() => _socket.close();
 
   void shutdown(SocketDirection direction) => _socket.shutdown(direction);
 
   int get port => _socket.port;
 
   int get remotePort => _socket.remotePort;
 
-  InternetAddress get address => _socket.address;
+  String get host => _socket.host;
 
   String get remoteHost => _socket.remoteHost;
 
   bool get readEventsEnabled => _readEventsEnabled;
   void set readEventsEnabled(bool value) {
     if (value != _readEventsEnabled) {
       _readEventsEnabled = value;
       if (!_controller.isPaused) _resume();
     }
   }
@@ skipping 67 matching lines @@
         cancelOnError: cancelOnError);
   }
 
   int get port => _socket.port;
 
   void close() => _socket.close();
 }
 
 
 patch class Socket {
-  /* patch */ static Future<Socket> connect(host, int port) {
+  /* patch */ static Future<Socket> connect(String host, int port) {
     return RawSocket.connect(host, port).then(
         (socket) => new _Socket(socket));
   }
 }
 
 
 patch class SecureSocket {
   /* patch */ factory SecureSocket._(RawSecureSocket rawSocket) =>
       new _SecureSocket(rawSocket);
 }
@@ skipping 299 matching lines @@
     _raw.onBadCertificate = callback;
   }
 
   X509Certificate get peerCertificate {
     if (_raw == null) {
      throw new StateError("peerCertificate called on destroyed SecureSocket");
     }
     return _raw.peerCertificate;
   }
 }