Patches to support Dart VM patch files in dart2js.

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}) {
@@ skipping 302 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 double get timestamp => sw.elapsedMicroseconds / 1000000.0;
-
   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]);
@@ skipping 45 matching lines @@
       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(response, "Failed host lookup: '$host'");
+                  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();
@@ skipping 69 matching lines @@
                                     int port,
                                     int backlog,
                                     bool v6Only,
                                     bool shared) {
     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 lookup: '$host'");
+                  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,
@@ skipping 17 matching lines @@
   }
 
   static Future<_NativeSocket> bindDatagram(
       host, int port, bool reuseAddress) {
     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 lookup: '$host'");
+                  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",
@@ skipping 1173 matching lines @@
 }
 
 
 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 {
+class _RawDatagramSocket extends Stream<RawSocketEvent>
+    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,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
@@ skipping 123 matching lines @@
 Datagram _makeDatagram(List<int> data,
                        String address,
                        List<int> in_addr,
                        int port) {
   return new Datagram(
       data,
       new _InternetAddress(address, null, in_addr),
       port);
 }