Revert "Fix observatory tests broken by running dartfmt."

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(address, int port,
-      {int backlog: 0, bool v6Only: false, bool shared: false}) {
+@patch class RawServerSocket {
+  @patch static Future<RawServerSocket> bind(address,
+                                                  int port,
+                                                  {int backlog: 0,
+                                                   bool v6Only: false,
+                                                   bool shared: false}) {
     return _RawServerSocket.bind(address, port, backlog, v6Only, shared);
   }
 }
 
-@patch
-class RawSocket {
-  @patch
-  static Future<RawSocket> connect(host, int port, {sourceAddress}) {
+
+@patch class RawSocket {
+  @patch static Future<RawSocket> connect(
+      host, int port, {sourceAddress}) {
     return _RawSocket.connect(host, port, sourceAddress);
   }
 }
 
-@patch
-class InternetAddress {
-  @patch
-  static InternetAddress get LOOPBACK_IP_V4 {
+
+@patch class InternetAddress {
+  @patch static InternetAddress get LOOPBACK_IP_V4 {
     return _InternetAddress.LOOPBACK_IP_V4;
   }
 
-  @patch
-  static InternetAddress get LOOPBACK_IP_V6 {
+  @patch static InternetAddress get LOOPBACK_IP_V6 {
     return _InternetAddress.LOOPBACK_IP_V6;
   }
 
-  @patch
-  static InternetAddress get ANY_IP_V4 {
+  @patch static InternetAddress get ANY_IP_V4 {
     return _InternetAddress.ANY_IP_V4;
   }
 
-  @patch
-  static InternetAddress get ANY_IP_V6 {
+  @patch static InternetAddress get ANY_IP_V6 {
     return _InternetAddress.ANY_IP_V6;
   }
 
-  @patch
-  factory InternetAddress(String address) {
+  @patch factory InternetAddress(String address) {
     return new _InternetAddress.parse(address);
   }
 
-  @patch
-  static Future<List<InternetAddress>> lookup(String host,
-      {InternetAddressType type: InternetAddressType.ANY}) {
+  @patch static Future<List<InternetAddress>> lookup(
+      String host, {InternetAddressType type: InternetAddressType.ANY}) {
     return _NativeSocket.lookup(host, type: type);
   }
 
-  @patch
-  static InternetAddress _cloneWithNewHost(
+  @patch static InternetAddress _cloneWithNewHost(
       InternetAddress address, String host) {
     return (address as _InternetAddress)._cloneWithNewHost(host);
   }
 }
 
-@patch
-class NetworkInterface {
-  @patch
-  static bool get listSupported {
+@patch class NetworkInterface {
+  @patch static bool get listSupported {
     return _listSupported();
   }
 
-  @patch
-  static Future<List<NetworkInterface>> list(
-      {bool includeLoopback: false,
+  @patch static Future<List<NetworkInterface>> list({
+      bool includeLoopback: false,
       bool includeLinkLocal: false,
       InternetAddressType type: InternetAddressType.ANY}) {
-    return _NativeSocket.listInterfaces(
-        includeLoopback: includeLoopback,
-        includeLinkLocal: includeLinkLocal,
-        type: type);
+    return _NativeSocket.listInterfaces(includeLoopback: includeLoopback,
+                                        includeLinkLocal: includeLinkLocal,
+                                        type: type);
   }
 
   static bool _listSupported() native "NetworkInterface_ListSupported";
 }
 
 void _throwOnBadPort(int port) {
   if ((port == null) || (port < 0) || (port > 0xFFFF)) {
     throw new ArgumentError("Invalid port $port");
   }
 }
@@ skipping 12 matching lines @@
       new _InternetAddress.fixed(_ADDRESS_LOOPBACK_IP_V6);
   static _InternetAddress ANY_IP_V4 =
       new _InternetAddress.fixed(_ADDRESS_ANY_IP_V4);
   static _InternetAddress ANY_IP_V6 =
       new _InternetAddress.fixed(_ADDRESS_ANY_IP_V6);
 
   final String address;
   final String _host;
   final Uint8List _in_addr;
 
-  InternetAddressType get type => _in_addr.length == _IPV4_ADDR_LENGTH
-      ? InternetAddressType.IP_V4
-      : InternetAddressType.IP_V6;
+  InternetAddressType get type =>
+      _in_addr.length == _IPV4_ADDR_LENGTH ? InternetAddressType.IP_V4
+                                           : InternetAddressType.IP_V6;
 
   String get host => _host != null ? _host : address;
 
   List<int> get rawAddress => new Uint8List.fromList(_in_addr);
 
   bool get isLoopback {
     switch (type) {
       case InternetAddressType.IP_V4:
         return _in_addr[0] == 127;
 
@@ skipping 27 matching lines @@
         // Checking for ff00::/8.
         return _in_addr[0] == 0xFF;
     }
   }
 
   Future<InternetAddress> reverse() => _NativeSocket.reverseLookup(this);
 
   _InternetAddress(this.address, this._host, this._in_addr);
 
   factory _InternetAddress.parse(String address) {
-    if (address is! String) {
+    if (address is !String) {
       throw new ArgumentError("Invalid internet address $address");
     }
     var in_addr = _parse(address);
     if (in_addr == null) {
       throw new ArgumentError("Invalid internet address $address");
     }
     return new _InternetAddress(address, null, in_addr);
   }
 
   factory _InternetAddress.fixed(int id) {
@@ skipping 55 matching lines @@
   final int index;
   final List<InternetAddress> addresses = [];
 
   _NetworkInterface(this.name, this.index);
 
   String toString() {
     return "NetworkInterface('$name', $addresses)";
   }
 }
 
+
 // The NativeFieldWrapperClass1 can not be used with a mixin, due to missing
 // implicit constructor.
 class _NativeSocketNativeWrapper extends NativeFieldWrapperClass1 {}
 
+
 // The _NativeSocket class encapsulates an OS socket.
 class _NativeSocket extends _NativeSocketNativeWrapper with _ServiceObject {
   // 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 29 matching lines @@
   // Protocol flags.
   static const int TCP_SOCKET = 18;
   static const int UDP_SOCKET = 19;
   static const int INTERNAL_SOCKET = 20;
   static const int TYPE_TCP_SOCKET = 1 << TCP_SOCKET;
   static const int TYPE_UDP_SOCKET = 1 << UDP_SOCKET;
   static const int TYPE_INTERNAL_SOCKET = 1 << INTERNAL_SOCKET;
   static const int TYPE_PROTOCOL_MASK =
       TYPE_TCP_SOCKET | TYPE_UDP_SOCKET | TYPE_INTERNAL_SOCKET;
 
+
   // Native port messages.
   static const HOST_NAME_LOOKUP = 0;
   static const LIST_INTERFACES = 1;
   static const REVERSE_LOOKUP = 2;
 
   // Protocol flags.
   static const int PROTOCOL_IPV4 = 1 << 0;
   static const int PROTOCOL_IPV6 = 1 << 1;
 
   static const int NORMAL_TOKEN_BATCH_SIZE = 8;
@@ skipping 36 matching lines @@
   bool writeEventIssued = false;
   bool writeAvailable = false;
 
   static bool connectedResourceHandler = false;
   _ReadWriteResourceInfo resourceInfo;
 
   // The owner object is the object that the Socket is being used by, e.g.
   // a HttpServer, a WebSocket connection, a process pipe, etc.
   Object owner;
 
-  static Future<List<InternetAddress>> lookup(String host,
-      {InternetAddressType type: InternetAddressType.ANY}) {
-    return _IOService
-        ._dispatch(_SOCKET_LOOKUP, [host, type._value]).then((response) {
-      if (isErrorResponse(response)) {
-        throw createError(response, "Failed host lookup: '$host'");
-      } else {
-        return response.skip(1).map((result) {
-          var type = new InternetAddressType._from(result[0]);
-          return new _InternetAddress(result[1], host, result[2]);
-        }).toList();
-      }
-    });
+  static Future<List<InternetAddress>> lookup(
+      String host, {InternetAddressType type: InternetAddressType.ANY}) {
+    return _IOService._dispatch(_SOCKET_LOOKUP, [host, type._value])
+        .then((response) {
+          if (isErrorResponse(response)) {
+            throw createError(response, "Failed host lookup: '$host'");
+          } else {
+            return response.skip(1).map((result) {
+              var type = new InternetAddressType._from(result[0]);
+              return new _InternetAddress(result[1], host, result[2]);
+            }).toList();
+          }
+        });
   }
 
   static Future<InternetAddress> reverseLookup(InternetAddress addr) {
-    return _IOService
-        ._dispatch(_SOCKET_REVERSE_LOOKUP, [addr._in_addr]).then((response) {
-      if (isErrorResponse(response)) {
-        throw createError(response, "Failed reverse host lookup", addr);
-      } else {
-        return addr._cloneWithNewHost(response);
-      }
-    });
+    return _IOService._dispatch(_SOCKET_REVERSE_LOOKUP, [addr._in_addr])
+        .then((response) {
+          if (isErrorResponse(response)) {
+            throw createError(response, "Failed reverse host lookup", addr);
+          } else {
+            return addr._cloneWithNewHost(response);
+          }
+        });
   }
 
-  static Future<List<NetworkInterface>> listInterfaces(
-      {bool includeLoopback: false,
+  static Future<List<NetworkInterface>> listInterfaces({
+      bool includeLoopback: false,
       bool includeLinkLocal: false,
       InternetAddressType type: InternetAddressType.ANY}) {
-    return _IOService
-        ._dispatch(_SOCKET_LIST_INTERFACES, [type._value]).then((response) {
-      if (isErrorResponse(response)) {
-        throw createError(response, "Failed listing interfaces");
-      } else {
-        var map = response.skip(1).fold(new Map<String, NetworkInterface>(),
-            (map, result) {
-          var type = new InternetAddressType._from(result[0]);
-          var name = result[3];
-          var index = result[4];
-          var address = new _InternetAddress(result[1], "", result[2]);
-          if (!includeLinkLocal && address.isLinkLocal) return map;
-          if (!includeLoopback && address.isLoopback) return map;
-          map.putIfAbsent(name, () => new _NetworkInterface(name, index));
-          map[name].addresses.add(address);
-          return map;
+    return _IOService._dispatch(_SOCKET_LIST_INTERFACES, [type._value])
+        .then((response) {
+          if (isErrorResponse(response)) {
+            throw createError(response, "Failed listing interfaces");
+          } else {
+            var map = response.skip(1)
+                .fold(new Map<String, NetworkInterface>(), (map, result) {
+                  var type = new InternetAddressType._from(result[0]);
+                  var name = result[3];
+                  var index = result[4];
+                  var address = new _InternetAddress(result[1], "", result[2]);
+                  if (!includeLinkLocal && address.isLinkLocal) return map;
+                  if (!includeLoopback && address.isLoopback) return map;
+                  map.putIfAbsent(
+                      name, () => new _NetworkInterface(name, index));
+                  map[name].addresses.add(address);
+                  return map;
+                });
+            return map.values.toList();
+          }
         });
-        return map.values.toList();
-      }
-    });
   }
 
   static Future<_NativeSocket> connect(host, int port, sourceAddress) {
     _throwOnBadPort(port);
     if (sourceAddress != null && sourceAddress is! _InternetAddress) {
       if (sourceAddress is String) {
         sourceAddress = new InternetAddress(sourceAddress);
       }
     }
-    return new Future.value(host).then((host) {
-      if (host is _InternetAddress) return [host];
-      return lookup(host).then((addresses) {
-        if (addresses.isEmpty) {
-          throw createError(null, "Failed host lookup: '$host'");
-        }
-        return addresses;
-      });
-    }).then((addresses) {
-      assert(addresses is List);
-      var completer = new Completer();
-      var it = addresses.iterator;
-      var error = null;
-      var connecting = new HashMap();
-      void connectNext() {
-        if (!it.moveNext()) {
-          if (connecting.isEmpty) {
-            assert(error != null);
-            completer.completeError(error);
-          }
-          return;
-        }
-        var address = it.current;
-        var socket = new _NativeSocket.normal();
-        socket.localAddress = address;
-        var result;
-        if (sourceAddress == null) {
-          result = socket.nativeCreateConnect(address._in_addr, port);
-        } else {
-          assert(sourceAddress is _InternetAddress);
-          result = socket.nativeCreateBindConnect(
-              address._in_addr, port, sourceAddress._in_addr);
-        }
-        if (result is OSError) {
-          // Keep first error, if present.
-          if (error == null) {
-            int errorCode = result.errorCode;
-            if (errorCode != null && socket.isBindError(errorCode)) {
-              error = createError(result, "Bind failed", sourceAddress);
+    return new Future.value(host)
+        .then((host) {
+          if (host is _InternetAddress) return [host];
+          return lookup(host)
+              .then((addresses) {
+                if (addresses.isEmpty) {
+                  throw createError(null, "Failed host lookup: '$host'");
+                }
+                return addresses;
+              });
+        })
+        .then((addresses) {
+          assert(addresses is List);
+          var completer = new Completer();
+          var it = addresses.iterator;
+          var error = null;
+          var connecting = new HashMap();
+          void connectNext() {
+            if (!it.moveNext()) {
+              if (connecting.isEmpty) {
+                assert(error != null);
+                completer.completeError(error);
+              }
+              return;
+            }
+            var address = it.current;
+            var socket = new _NativeSocket.normal();
+            socket.localAddress = address;
+            var result;
+            if (sourceAddress == null) {
+              result = socket.nativeCreateConnect(address._in_addr, port);
             } else {
-              error = createError(result, "Connection failed", address, port);
+              assert(sourceAddress is _InternetAddress);
+              result = socket.nativeCreateBindConnect(
+                  address._in_addr, port, sourceAddress._in_addr);
+            }
+            if (result is OSError) {
+              // Keep first error, if present.
+              if (error == null) {
+                int errorCode = result.errorCode;
+                if (errorCode != null && socket.isBindError(errorCode)) {
+                  error = createError(result, "Bind failed", sourceAddress);
+                } else {
+                  error =
+                      createError(result, "Connection failed", address, port);
+                }
+              }
+              connectNext();
+            } else {
+              // Query the local port, for error messages.
+              try {
+                socket.port;
+              } catch (e) {
+                error = createError(e, "Connection failed", address, port);
+                connectNext();
+              }
+              // Set up timer for when we should retry the next address
+              // (if any).
+              var duration = address.isLoopback ?
+                  _RETRY_DURATION_LOOPBACK :
+                  _RETRY_DURATION;
+              var timer = new Timer(duration, connectNext);
+              setupResourceInfo(socket);
+
+              connecting[socket] = timer;
+              // Setup handlers for receiving the first write event which
+              // indicate that the socket is fully connected.
+              socket.setHandlers(
+                  write: () {
+                    timer.cancel();
+                    socket.setListening(read: false, write: false);
+                    completer.complete(socket);
+                    connecting.remove(socket);
+                    connecting.forEach((s, t) {
+                      t.cancel();
+                      s.close();
+                      s.setHandlers();
+                      s.setListening(read: false, write: false);
+                    });
+                  },
+                  error: (e) {
+                    timer.cancel();
+                    socket.close();
+                    // Keep first error, if present.
+                    if (error == null) error = e;
+                    connecting.remove(socket);
+                    if (connecting.isEmpty) connectNext();
+                  });
+              socket.setListening(read: false, write: true);
             }
           }
           connectNext();
-        } else {
-          // Query the local port, for error messages.
-          try {
-            socket.port;
-          } catch (e) {
-            error = createError(e, "Connection failed", address, port);
-            connectNext();
-          }
-          // Set up timer for when we should retry the next address
-          // (if any).
-          var duration =
-              address.isLoopback ? _RETRY_DURATION_LOOPBACK : _RETRY_DURATION;
-          var timer = new Timer(duration, connectNext);
-          setupResourceInfo(socket);
-
-          connecting[socket] = timer;
-          // Setup handlers for receiving the first write event which
-          // indicate that the socket is fully connected.
-          socket.setHandlers(write: () {
-            timer.cancel();
-            socket.setListening(read: false, write: false);
-            completer.complete(socket);
-            connecting.remove(socket);
-            connecting.forEach((s, t) {
-              t.cancel();
-              s.close();
-              s.setHandlers();
-              s.setListening(read: false, write: false);
-            });
-          }, error: (e) {
-            timer.cancel();
-            socket.close();
-            // Keep first error, if present.
-            if (error == null) error = e;
-            connecting.remove(socket);
-            if (connecting.isEmpty) connectNext();
-          });
-          socket.setListening(read: false, write: true);
-        }
-      }
-
-      connectNext();
-      return completer.future;
-    });
+          return completer.future;
+        });
   }
 
-  static Future<_NativeSocket> bind(
-      host, int port, int backlog, bool v6Only, bool shared) {
+  static Future<_NativeSocket> bind(host,
+                                    int port,
+                                    int backlog,
+                                    bool v6Only,
+                                    bool shared) {
     _throwOnBadPort(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(null, "Failed host lookup: '$host'");
-        }
-        return list[0];
-      });
-    }).then((address) {
-      var socket = new _NativeSocket.listen();
-      socket.localAddress = address;
-      var result = socket.nativeCreateBindListen(
-          address._in_addr, port, backlog, v6Only, shared);
-      if (result is OSError) {
-        throw new SocketException("Failed to create server socket",
-            osError: result, address: address, port: port);
-      }
-      if (port != 0) socket.localPort = port;
-      setupResourceInfo(socket);
-      socket.connectToEventHandler();
-      return socket;
-    });
+    return new Future.value(host)
+        .then((host) {
+          if (host is _InternetAddress) return host;
+          return lookup(host)
+              .then((list) {
+                if (list.length == 0) {
+                  throw createError(null, "Failed host lookup: '$host'");
+                }
+                return list[0];
+              });
+        })
+        .then((address) {
+          var socket = new _NativeSocket.listen();
+          socket.localAddress = address;
+          var result = socket.nativeCreateBindListen(address._in_addr,
+                                                     port,
+                                                     backlog,
+                                                     v6Only,
+                                                     shared);
+          if (result is OSError) {
+            throw new SocketException("Failed to create server socket",
+                                      osError: result,
+                                      address: address,
+                                      port: port);
+          }
+          if (port != 0) socket.localPort = port;
+          setupResourceInfo(socket);
+          socket.connectToEventHandler();
+          return socket;
+        });
   }
 
   static void setupResourceInfo(_NativeSocket socket) {
     socket.resourceInfo = new _SocketResourceInfo(socket);
   }
 
-  static Future<_NativeSocket> bindDatagram(host, int port, bool reuseAddress) {
+  static Future<_NativeSocket> bindDatagram(
+      host, int port, bool reuseAddress) {
     _throwOnBadPort(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(null, "Failed host lookup: '$host'");
-        }
-        return list[0];
-      });
-    }).then((address) {
-      var socket = new _NativeSocket.datagram(address);
-      var result =
-          socket.nativeCreateBindDatagram(address._in_addr, port, reuseAddress);
-      if (result is OSError) {
-        throw new SocketException("Failed to create datagram socket",
-            osError: result, address: address, port: port);
-      }
-      if (port != 0) socket.localPort = port;
-      setupResourceInfo(socket);
-      return socket;
-    });
+    return new Future.value(host)
+        .then((host) {
+          if (host is _InternetAddress) return host;
+          return lookup(host)
+              .then((list) {
+                if (list.length == 0) {
+                  throw createError(null, "Failed host lookup: '$host'");
+                }
+                return list[0];
+              });
+        })
+        .then((address) {
+          var socket = new _NativeSocket.datagram(address);
+          var result = socket.nativeCreateBindDatagram(
+              address._in_addr, port, reuseAddress);
+          if (result is OSError) {
+            throw new SocketException("Failed to create datagram socket",
+                                      osError: result,
+                                      address: address,
+                                      port: port);
+          }
+          if (port != 0) socket.localPort = port;
+          setupResourceInfo(socket);
+          return socket;
+        });
   }
 
   _NativeSocket.datagram(this.localAddress)
-      : typeFlags = TYPE_NORMAL_SOCKET | TYPE_UDP_SOCKET;
+    : typeFlags = TYPE_NORMAL_SOCKET | TYPE_UDP_SOCKET;
 
   _NativeSocket.normal() : typeFlags = TYPE_NORMAL_SOCKET | TYPE_TCP_SOCKET;
 
   _NativeSocket.listen() : typeFlags = TYPE_LISTENING_SOCKET | TYPE_TCP_SOCKET {
     isClosedWrite = true;
   }
 
   _NativeSocket.pipe() : typeFlags = TYPE_PIPE;
 
   _NativeSocket.watch(int id)
@@ skipping 100 matching lines @@
     // Negate the result, as stated above.
     if (result < 0) result = -result;
     // TODO(ricow): Remove when we track internal and pipe uses.
     assert(resourceInfo != null || isPipe || isInternal);
     if (resourceInfo != null) {
       resourceInfo.addWrite(result);
     }
     return result;
   }
 
-  int send(List<int> buffer, int offset, int bytes, InternetAddress address,
-      int port) {
+  int send(List<int> buffer, int offset, int bytes,
+           InternetAddress address, int port) {
     _throwOnBadPort(port);
     if (isClosing || isClosed) return 0;
     _BufferAndStart bufferAndStart =
-        _ensureFastAndSerializableByteData(buffer, offset, bytes);
-    var result = nativeSendTo(bufferAndStart.buffer, bufferAndStart.start,
-        bytes, address._in_addr, port);
+        _ensureFastAndSerializableByteData(
+            buffer, offset, bytes);
+    var result = nativeSendTo(
+        bufferAndStart.buffer, bufferAndStart.start, bytes,
+        address._in_addr, port);
     if (result is OSError) {
       OSError osError = result;
       scheduleMicrotask(() => reportError(osError, "Send failed"));
       result = 0;
     }
     // TODO(ricow): Remove when we track internal and pipe uses.
     assert(resourceInfo != null || isPipe || isInternal);
     if (resourceInfo != null) {
       resourceInfo.addWrite(result);
     }
@@ skipping 64 matching lines @@
           handler();
         }
         return;
       }
       var handler = eventHandlers[READ_EVENT];
       if (handler == null) return;
       readEventIssued = true;
       handler();
       scheduleMicrotask(issue);
     }
-
     scheduleMicrotask(issue);
   }
 
   void issueWriteEvent({bool delayed: true}) {
     if (writeEventIssued) return;
     if (!writeAvailable) return;
     void issue() {
       writeEventIssued = false;
       if (!writeAvailable) return;
       if (isClosing) return;
       if (!sendWriteEvents) return;
       sendWriteEvents = false;
       var handler = eventHandlers[WRITE_EVENT];
       if (handler == null) return;
       handler();
     }
-
     if (delayed) {
       writeEventIssued = true;
       scheduleMicrotask(issue);
     } else {
       issue();
     }
   }
 
   // Multiplexes socket events to the socket handlers.
   void multiplex(int events) {
     for (int i = FIRST_EVENT; i <= LAST_EVENT; i++) {
       if (((events & (1 << i)) != 0)) {
         if ((i == CLOSED_EVENT || i == READ_EVENT) && isClosedRead) continue;
         if (isClosing && i != DESTROYED_EVENT) continue;
-        if (i == CLOSED_EVENT && !isListening && !isClosing && !isClosed) {
+        if (i == CLOSED_EVENT &&
+            !isListening  &&
+            !isClosing &&
+            !isClosed) {
           isClosedRead = true;
           issueReadEvent();
           continue;
         }
 
         if (i == WRITE_EVENT) {
           writeAvailable = true;
           issueWriteEvent(delayed: false);
           continue;
         }
@@ skipping 129 matching lines @@
     connectToEventHandler();
     _EventHandler._sendData(this, eventPort.sendPort, fullData);
   }
 
   void connectToEventHandler() {
     assert(!isClosed);
     if (eventPort == null) {
       eventPort = new RawReceivePort(multiplex);
     }
     if (!connectedResourceHandler) {
-      registerExtension(
-          'ext.dart.io.getOpenSockets', _SocketResourceInfo.getOpenSockets);
+      registerExtension('ext.dart.io.getOpenSockets',
+                        _SocketResourceInfo.getOpenSockets);
       registerExtension('ext.dart.io.getSocketByID',
-          _SocketResourceInfo.getSocketInfoMapByID);
+                        _SocketResourceInfo.getSocketInfoMapByID);
 
       connectedResourceHandler = true;
     }
   }
 
   void disconnectFromEventHandler() {
     assert(eventPort != null);
     eventPort.close();
     eventPort = null;
     // Now that we don't track this Socket anymore, we can clear the owner
     // field.
     owner = null;
   }
 
   // Check whether this is an error response from a native port call.
   static bool isErrorResponse(response) {
     return response is List && response[0] != _SUCCESS_RESPONSE;
   }
 
   // Create the appropriate error/exception from different returned
   // error objects.
-  static createError(error, String message,
-      [InternetAddress address, int port]) {
+  static createError(error,
+                     String message,
+                     [InternetAddress address,
+                      int port]) {
     if (error is OSError) {
-      return new SocketException(message,
-          osError: error, address: address, port: port);
+      return new SocketException(
+          message, osError: error, address: address, port: port);
     } else if (error is List) {
       assert(isErrorResponse(error));
       switch (error[0]) {
         case _ILLEGAL_ARGUMENT_RESPONSE:
           return new ArgumentError();
         case _OSERROR_RESPONSE:
           return new SocketException(message,
-              osError: new OSError(error[2], error[1]),
-              address: address,
-              port: port);
+                                     osError: new OSError(error[2], error[1]),
+                                     address: address,
+                                     port: port);
         default:
           return new Exception("Unknown error");
       }
     } else {
       return new SocketException(message, address: address, port: port);
     }
   }
 
   void reportError(error, String message) {
     var e = createError(error, message, address, localPort);
@@ skipping 38 matching lines @@
         return InternetAddress.ANY_IP_V4;
       }
     } else {
       return null;
     }
   }
 
   void joinMulticast(InternetAddress addr, NetworkInterface interface) {
     var interfaceAddr = multicastAddress(addr, interface);
     var interfaceIndex = interface == null ? 0 : interface.index;
-    var result = nativeJoinMulticast(addr._in_addr,
-        interfaceAddr == null ? null : interfaceAddr._in_addr, interfaceIndex);
+    var result = nativeJoinMulticast(
+        addr._in_addr,
+        interfaceAddr == null ? null : interfaceAddr._in_addr,
+        interfaceIndex);
     if (result is OSError) throw result;
   }
 
   void leaveMulticast(InternetAddress addr, NetworkInterface interface) {
     var interfaceAddr = multicastAddress(addr, interface);
     var interfaceIndex = interface == null ? 0 : interface.index;
-    var result = nativeLeaveMulticast(addr._in_addr,
-        interfaceAddr == null ? null : interfaceAddr._in_addr, interfaceIndex);
+    var result = nativeLeaveMulticast(
+        addr._in_addr,
+        interfaceAddr == null ? null : interfaceAddr._in_addr,
+        interfaceIndex);
     if (result is OSError) throw result;
   }
 
+
   void nativeSetSocketId(int id) native "Socket_SetSocketId";
   nativeAvailable() native "Socket_Available";
   nativeRead(int len) native "Socket_Read";
   nativeRecvFrom() native "Socket_RecvFrom";
   nativeWrite(List<int> buffer, int offset, int bytes)
       native "Socket_WriteList";
-  nativeSendTo(List<int> buffer, int offset, int bytes, List<int> address,
-      int port) native "Socket_SendTo";
-  nativeCreateConnect(List<int> addr, int port) native "Socket_CreateConnect";
-  nativeCreateBindConnect(List<int> addr, int port, List<int> sourceAddr)
+  nativeSendTo(List<int> buffer, int offset, int bytes,
+               List<int> address, int port)
+      native "Socket_SendTo";
+  nativeCreateConnect(List<int> addr,
+                      int port) native "Socket_CreateConnect";
+  nativeCreateBindConnect(
+      List<int> addr, int port, List<int> sourceAddr)
       native "Socket_CreateBindConnect";
   bool isBindError(int errorNumber) native "Socket_IsBindError";
   nativeCreateBindListen(List<int> addr, int port, int backlog, bool v6Only,
-      bool shared) native "ServerSocket_CreateBindListen";
+                         bool shared)
+      native "ServerSocket_CreateBindListen";
   nativeCreateBindDatagram(List<int> addr, int port, bool reuseAddress)
       native "Socket_CreateBindDatagram";
   nativeAccept(_NativeSocket socket) native "ServerSocket_Accept";
   int nativeGetPort() native "Socket_GetPort";
   List nativeGetRemotePeer() native "Socket_GetRemotePeer";
   int nativeGetSocketId() native "Socket_GetSocketId";
   OSError nativeGetError() native "Socket_GetError";
   nativeGetOption(int option, int protocol) native "Socket_GetOption";
   bool nativeSetOption(int option, int protocol, value)
       native "Socket_SetOption";
-  OSError nativeJoinMulticast(List<int> addr, List<int> interfaceAddr,
-      int interfaceIndex) native "Socket_JoinMulticast";
-  bool nativeLeaveMulticast(List<int> addr, List<int> interfaceAddr,
-      int interfaceIndex) native "Socket_LeaveMulticast";
+  OSError nativeJoinMulticast(
+      List<int> addr, List<int> interfaceAddr, int interfaceIndex)
+          native "Socket_JoinMulticast";
+  bool nativeLeaveMulticast(
+      List<int> addr, List<int> interfaceAddr, int interfaceIndex)
+      native "Socket_LeaveMulticast";
 }
 
-class _RawServerSocket extends Stream<RawSocket> implements RawServerSocket {
+
+class _RawServerSocket extends Stream<RawSocket>
+                       implements RawServerSocket {
   final _NativeSocket _socket;
   StreamController<RawSocket> _controller;
   ReceivePort _referencePort;
   bool _v6Only;
 
-  static Future<_RawServerSocket> bind(
-      address, int port, int backlog, bool v6Only, bool shared) {
+  static Future<_RawServerSocket> bind(address,
+                                       int port,
+                                       int backlog,
+                                       bool v6Only,
+                                       bool shared) {
     _throwOnBadPort(port);
     if (backlog < 0) throw new ArgumentError("Invalid backlog $backlog");
-    return _NativeSocket
-        .bind(address, port, backlog, v6Only, shared)
+    return _NativeSocket.bind(address, port, backlog, v6Only, shared)
         .then((socket) => new _RawServerSocket(socket, v6Only));
   }
 
   _RawServerSocket(this._socket, this._v6Only);
 
   StreamSubscription<RawSocket> listen(void onData(RawSocket event),
-      {Function onError, void onDone(), bool cancelOnError}) {
+                                       {Function onError,
+                                        void onDone(),
+                                        bool cancelOnError}) {
     if (_controller != null) {
       throw new StateError("Stream was already listened to");
     }
     var zone = Zone.current;
-    _controller = new StreamController(
-        sync: true,
+    _controller = new StreamController(sync: true,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
-    _socket.setHandlers(read: zone.bindCallback(() {
-      while (_socket.available > 0) {
-        var socket = _socket.accept();
-        if (socket == null) return;
-        _controller.add(new _RawSocket(socket));
-        if (_controller.isPaused) return;
-      }
-    }), error: zone.bindUnaryCallback((e) {
-      _controller.addError(e);
-      _controller.close();
-    }), destroyed: () {
-      _controller.close();
-      if (_referencePort != null) {
-        _referencePort.close();
-        _referencePort = null;
-      }
-    });
-    return _controller.stream.listen(onData,
-        onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+    _socket.setHandlers(
+      read: zone.bindCallback(() {
+        while (_socket.available > 0) {
+          var socket = _socket.accept();
+          if (socket == null) return;
+          _controller.add(new _RawSocket(socket));
+          if (_controller.isPaused) return;
+        }
+      }),
+      error: zone.bindUnaryCallback((e) {
+        _controller.addError(e);
+        _controller.close();
+      }),
+      destroyed: () {
+        _controller.close();
+        if (_referencePort != null) {
+          _referencePort.close();
+          _referencePort = null;
+        }
+      });
+    return _controller.stream.listen(
+        onData,
+        onError: onError,
+        onDone: onDone,
+        cancelOnError: cancelOnError);
   }
 
   int get port => _socket.port;
 
   InternetAddress get address => _socket.address;
 
   Future close() {
     return _socket.close().then((_) {
       if (_referencePort != null) {
         _referencePort.close();
@@ skipping 20 matching lines @@
   }
 
   void _onPauseStateChange() {
     if (_controller.isPaused) {
       _pause();
     } else {
       _resume();
     }
   }
 
-  void set _owner(owner) {
-    _socket.owner = owner;
-  }
+  void set _owner(owner) { _socket.owner = owner; }
 }
 
-class _RawSocket extends Stream<RawSocketEvent> implements RawSocket {
+
+class _RawSocket extends Stream<RawSocketEvent>
+                 implements RawSocket {
   final _NativeSocket _socket;
   StreamController<RawSocketEvent> _controller;
   bool _readEventsEnabled = true;
   bool _writeEventsEnabled = true;
 
   // Flag to handle Ctrl-D closing of stdio on Mac OS.
   bool _isMacOSTerminalInput = false;
 
   static Future<RawSocket> connect(host, int port, sourceAddress) {
-    return _NativeSocket
-        .connect(host, port, sourceAddress)
+    return _NativeSocket.connect(host, port, sourceAddress)
         .then((socket) => new _RawSocket(socket));
   }
 
   _RawSocket(this._socket) {
     var zone = Zone.current;
-    _controller = new StreamController(
-        sync: true,
+    _controller = new StreamController(sync: true,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
     _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),
-        destroyed: () {
-          _controller.add(RawSocketEvent.CLOSED);
-          _controller.close();
-        },
-        error: zone.bindUnaryCallback((e) {
-          _controller.addError(e);
-          _socket.close();
-        }));
+      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),
+      destroyed: () {
+        _controller.add(RawSocketEvent.CLOSED);
+        _controller.close();
+      },
+      error: zone.bindUnaryCallback((e) {
+        _controller.addError(e);
+        _socket.close();
+      })
+    );
   }
 
   factory _RawSocket._writePipe() {
     var native = new _NativeSocket.pipe();
     native.isClosedRead = true;
     native.closedReadEventSent = true;
     return new _RawSocket(native);
   }
 
   factory _RawSocket._readPipe(int fd) {
     var native = new _NativeSocket.pipe();
     native.isClosedWrite = true;
     if (fd != null) _getStdioHandle(native, fd);
     var result = new _RawSocket(native);
     if (fd != null) {
       var socketType = _StdIOUtils._nativeSocketType(result._socket);
       result._isMacOSTerminalInput =
           Platform.isMacOS && socketType == _STDIO_HANDLE_TYPE_TERMINAL;
     }
     return result;
   }
 
   StreamSubscription<RawSocketEvent> listen(void onData(RawSocketEvent event),
-      {Function onError, void onDone(), bool cancelOnError}) {
-    return _controller.stream.listen(onData,
-        onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+                                            {Function onError,
+                                             void onDone(),
+                                             bool cancelOnError}) {
+    return _controller.stream.listen(
+        onData,
+        onError: onError,
+        onDone: onDone,
+        cancelOnError: cancelOnError);
   }
 
   int available() => _socket.available;
 
   List<int> read([int len]) {
     if (_isMacOSTerminalInput) {
       var available = this.available();
       if (available == 0) return null;
       var data = _socket.read(len);
       if (data == null || data.length < available) {
@@ skipping 58 matching lines @@
   }
 
   void _onSubscriptionStateChange() {
     if (_controller.hasListener) {
       _resume();
     } else {
       _socket.close();
     }
   }
 
-  void set _owner(owner) {
-    _socket.owner = owner;
-  }
+  void set _owner(owner) { _socket.owner = owner; }
 }
 
-@patch
-class ServerSocket {
-  @patch
-  static Future<ServerSocket> bind(address, int port,
-      {int backlog: 0, bool v6Only: false, bool shared: false}) {
+
+@patch class ServerSocket {
+  @patch static Future<ServerSocket> bind(address,
+                                               int port,
+                                               {int backlog: 0,
+                                                bool v6Only: false,
+                                                bool shared: false}) {
     return _ServerSocket.bind(address, port, backlog, v6Only, shared);
   }
 }
 
-class _ServerSocket extends Stream<Socket> implements ServerSocket {
+
+class _ServerSocket extends Stream<Socket>
+                    implements ServerSocket {
   final _socket;
 
-  static Future<_ServerSocket> bind(
-      address, int port, int backlog, bool v6Only, bool shared) {
-    return _RawServerSocket
-        .bind(address, port, backlog, v6Only, shared)
+  static Future<_ServerSocket> bind(address,
+                                    int port,
+                                    int backlog,
+                                    bool v6Only,
+                                    bool shared) {
+    return _RawServerSocket.bind(address, port, backlog, v6Only, shared)
         .then((socket) => new _ServerSocket(socket));
   }
 
   _ServerSocket(this._socket);
 
   StreamSubscription<Socket> listen(void onData(Socket event),
-      {Function onError, void onDone(), bool cancelOnError}) {
-    return _socket.map((rawSocket) => new _Socket(rawSocket)).listen(onData,
-        onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+                                    {Function onError,
+                                     void onDone(),
+                                     bool cancelOnError}) {
+    return _socket.map((rawSocket) => new _Socket(rawSocket)).listen(
+        onData,
+        onError: onError,
+        onDone: onDone,
+        cancelOnError: cancelOnError);
   }
 
   int get port => _socket.port;
 
   InternetAddress get address => _socket.address;
 
   Future close() => _socket.close().then((_) => this);
 
-  void set _owner(owner) {
-    _socket._owner = owner;
+  void set _owner(owner) { _socket._owner = owner; }
+}
+
+
+@patch class Socket {
+  @patch static Future<Socket> connect(host, int port, {sourceAddress}) {
+    return RawSocket.connect(host, port, sourceAddress: sourceAddress).then(
+        (socket) => new _Socket(socket));
   }
 }
 
-@patch
-class Socket {
-  @patch
-  static Future<Socket> connect(host, int port, {sourceAddress}) {
-    return RawSocket
-        .connect(host, port, sourceAddress: sourceAddress)
-        .then((socket) => new _Socket(socket));
-  }
-}
 
 class _SocketStreamConsumer extends StreamConsumer<List<int>> {
   StreamSubscription subscription;
   final _Socket socket;
   int offset;
   List<int> buffer;
   bool paused = false;
   Completer streamCompleter;
 
   _SocketStreamConsumer(this.socket);
 
   Future<Socket> addStream(Stream<List<int>> stream) {
     socket._ensureRawSocketSubscription();
     streamCompleter = new Completer<Socket>();
     if (socket._raw != null) {
-      subscription = stream.listen((data) {
-        assert(!paused);
-        assert(buffer == null);
-        buffer = data;
-        offset = 0;
-        try {
-          write();
-        } catch (e) {
-          socket.destroy();
-          stop();
-          done(e);
-        }
-      }, onError: (error, [stackTrace]) {
-        socket.destroy();
-        done(error, stackTrace);
-      }, onDone: () {
-        done();
-      }, cancelOnError: true);
+      subscription = stream.listen(
+          (data) {
+            assert(!paused);
+            assert(buffer == null);
+            buffer = data;
+            offset = 0;
+            try {
+              write();
+            } catch (e) {
+              socket.destroy();
+              stop();
+              done(e);
+            }
+          },
+          onError: (error, [stackTrace]) {
+            socket.destroy();
+            done(error, stackTrace);
+          },
+          onDone: () {
+            done();
+          },
+          cancelOnError: true);
     }
     return streamCompleter.future;
   }
 
   Future<Socket> close() {
     socket._consumerDone();
     return new Future.value(socket);
   }
 
   void write() {
@@ skipping 29 matching lines @@
 
   void stop() {
     if (subscription == null) return;
     subscription.cancel();
     subscription = null;
     paused = false;
     socket._disableWriteEvent();
   }
 }
 
+
 class _Socket extends Stream<List<int>> implements Socket {
-  RawSocket _raw; // Set to null when the raw socket is closed.
-  bool _closed = false; // Set to true when the raw socket is closed.
+  RawSocket _raw;  // Set to null when the raw socket is closed.
+  bool _closed = false;  // Set to true when the raw socket is closed.
   StreamController _controller;
   bool _controllerClosed = false;
   _SocketStreamConsumer _consumer;
   IOSink _sink;
   var _subscription;
   var _detachReady;
 
   _Socket(this._raw) {
-    _controller = new StreamController<List<int>>(
-        sync: true,
+    _controller = new StreamController<List<int>>(sync: true,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
     _consumer = new _SocketStreamConsumer(this);
     _sink = new IOSink(_consumer);
 
     // Disable read events until there is a subscription.
     _raw.readEventsEnabled = false;
 
     // Disable write events until the consumer needs it for pending writes.
     _raw.writeEventsEnabled = false;
   }
 
   factory _Socket._writePipe() {
     return new _Socket(new _RawSocket._writePipe());
   }
 
   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),
-      {Function onError, void onDone(), bool cancelOnError}) {
-    return _controller.stream.listen(onData,
-        onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+                                       {Function onError,
+                                        void onDone(),
+                                        bool cancelOnError}) {
+    return _controller.stream.listen(
+        onData,
+        onError: onError,
+        onDone: onDone,
+        cancelOnError: cancelOnError);
   }
 
   Encoding get encoding => _sink.encoding;
 
   void set encoding(Encoding value) {
     _sink.encoding = value;
   }
 
   void write(Object obj) => _sink.write(obj);
 
@@ skipping 23 matching lines @@
     _controllerClosed = true;
     _controller.close();
   }
 
   bool setOption(SocketOption option, bool enabled) {
     if (_raw == null) return false;
     return _raw.setOption(option, enabled);
   }
 
   int get port {
-    if (_raw == null) throw const SocketException.closed();
-    ;
+    if (_raw == null) throw const SocketException.closed();;
     return _raw.port;
   }
 
   InternetAddress get address {
-    if (_raw == null) throw const SocketException.closed();
-    ;
+    if (_raw == null) throw const SocketException.closed();;
     return _raw.address;
   }
 
   int get remotePort {
-    if (_raw == null) throw const SocketException.closed();
-    ;
+    if (_raw == null) throw const SocketException.closed();;
     return _raw.remotePort;
   }
 
   InternetAddress get remoteAddress {
-    if (_raw == null) throw const SocketException.closed();
-    ;
+    if (_raw == null) throw const SocketException.closed();;
     return _raw.remoteAddress;
   }
 
   Future _detachRaw() {
     _detachReady = new Completer();
     _sink.close();
     return _detachReady.future.then((_) {
       assert(_consumer.buffer == null);
       var raw = _raw;
       _raw = null;
       return [raw, _subscription];
     });
   }
 
   // Ensure a subscription on the raw socket. Both the stream and the
   // consumer needs a subscription as they share the error and done
   // events from the raw socket.
   void _ensureRawSocketSubscription() {
     if (_subscription == null && _raw != null) {
       _subscription = _raw.listen(_onData,
-          onError: _onError, onDone: _onDone, cancelOnError: true);
+                                  onError: _onError,
+                                  onDone: _onDone,
+                                  cancelOnError: true);
     }
   }
 
   _closeRawSocket() {
     var tmp = _raw;
     _raw = null;
     _closed = true;
     tmp.close();
   }
 
@@ skipping 68 matching lines @@
     if (_detachReady != null) {
       _detachReady.complete(null);
     } else {
       if (_raw != null) {
         _raw.shutdown(SocketDirection.SEND);
         _disableWriteEvent();
       }
     }
   }
 
-  void set _owner(owner) {
-    _raw._owner = owner;
-  }
+  void set _owner(owner) { _raw._owner = owner; }
 }
 
-@patch
-class RawDatagramSocket {
-  @patch
-  static Future<RawDatagramSocket> bind(host, int port,
-      {bool reuseAddress: true}) {
+
+@patch class RawDatagramSocket {
+  @patch static Future<RawDatagramSocket> bind(
+      host, int port, {bool reuseAddress: true}) {
     return _RawDatagramSocket.bind(host, port, reuseAddress);
   }
 }
 
 class _RawDatagramSocket extends Stream implements RawDatagramSocket {
   _NativeSocket _socket;
   StreamController<RawSocketEvent> _controller;
   bool _readEventsEnabled = true;
   bool _writeEventsEnabled = true;
 
   _RawDatagramSocket(this._socket) {
     var zone = Zone.current;
-    _controller = new StreamController(
-        sync: true,
+    _controller = new StreamController(sync: true,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
     _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),
-        destroyed: () {
-          _controller.add(RawSocketEvent.CLOSED);
-          _controller.close();
-        },
-        error: zone.bindUnaryCallback((e) {
-          _controller.addError(e);
-          _socket.close();
-        }));
+      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),
+      destroyed: () {
+        _controller.add(RawSocketEvent.CLOSED);
+        _controller.close();
+      },
+      error: zone.bindUnaryCallback((e) {
+        _controller.addError(e);
+        _socket.close();
+      })
+    );
   }
 
-  static Future<RawDatagramSocket> bind(host, int port, bool reuseAddress) {
+  static Future<RawDatagramSocket> bind(
+      host, int port, bool reuseAddress) {
     _throwOnBadPort(port);
-    return _NativeSocket
-        .bindDatagram(host, port, reuseAddress)
+    return _NativeSocket.bindDatagram(host, port, reuseAddress)
         .then((socket) => new _RawDatagramSocket(socket));
   }
 
   StreamSubscription<RawSocketEvent> listen(void onData(RawSocketEvent event),
-      {Function onError, void onDone(), bool cancelOnError}) {
-    return _controller.stream.listen(onData,
-        onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+                                            {Function onError,
+                                             void onDone(),
+                                             bool cancelOnError}) {
+    return _controller.stream.listen(
+        onData,
+        onError: onError,
+        onDone: onDone,
+        cancelOnError: cancelOnError);
   }
 
   Future close() => _socket.close().then((_) => this);
 
   int send(List<int> buffer, InternetAddress address, int port) =>
       _socket.send(buffer, 0, buffer.length, address, port);
 
   Datagram receive() {
     return _socket.receive();
   }
@@ skipping 20 matching lines @@
       _writeEventsEnabled = value;
       if (!_controller.isPaused) _resume();
     }
   }
 
   bool get multicastLoopback =>
       _socket.getOption(SocketOption._IP_MULTICAST_LOOP);
   void set multicastLoopback(bool value) =>
       _socket.setOption(SocketOption._IP_MULTICAST_LOOP, value);
 
-  int get multicastHops => _socket.getOption(SocketOption._IP_MULTICAST_HOPS);
+  int get multicastHops =>
+      _socket.getOption(SocketOption._IP_MULTICAST_HOPS);
   void set multicastHops(int value) =>
       _socket.setOption(SocketOption._IP_MULTICAST_HOPS, value);
 
-  NetworkInterface get multicastInterface => throw "Not implemented";
+  NetworkInterface get multicastInterface =>
+      throw "Not implemented";
   void set multicastInterface(NetworkInterface value) =>
       throw "Not implemented";
 
-  bool get broadcastEnabled => _socket.getOption(SocketOption._IP_BROADCAST);
+  bool get broadcastEnabled =>
+      _socket.getOption(SocketOption._IP_BROADCAST);
   void set broadcastEnabled(bool value) =>
       _socket.setOption(SocketOption._IP_BROADCAST, value);
 
   int get port => _socket.port;
 
   InternetAddress get address => _socket.address;
 
   _pause() {
     _socket.setListening(read: false, write: false);
   }
@@ skipping 12 matching lines @@
 
   void _onSubscriptionStateChange() {
     if (_controller.hasListener) {
       _resume();
     } else {
       _socket.close();
     }
   }
 }
 
-Datagram _makeDatagram(
-    List<int> data, String address, List<int> in_addr, int port) {
-  return new Datagram(data, new _InternetAddress(address, null, in_addr), port);
+Datagram _makeDatagram(List<int> data,
+                       String address,
+                       List<int> in_addr,
+                       int port) {
+  return new Datagram(
+      data,
+      new _InternetAddress(address, null, in_addr),
+      port);
 }
+