Dart: Futures -> Callbacks.

mojo/dart/embedder/io/server_socket_patch.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 //
 // Implementation of ServerSocket and RawServerSocket for Mojo.
 //
 
 patch class RawServerSocket {
   /* patch */ static Future<RawServerSocket> bind(address,
@@ skipping 10 matching lines @@
                                                int port,
                                                {int backlog: 0,
                                                 bool v6Only: false,
                                                 bool shared: false}) {
     return _MojoServerSocket.bind(address, port, backlog, v6Only, shared);
   }
 }
 
 class _MojoRawServerSocket extends Stream<RawSocket>
                            implements RawServerSocket {
-  final _tcpBoundSocket = new TcpBoundSocketProxy.unbound();
-  final _tcpServerSocket = new TcpServerSocketProxy.unbound();
+  final _tcpBoundSocket = new _TcpBoundSocketProxy.unbound();
+  final _tcpServerSocket = new _TcpServerSocketProxy.unbound();
   final bool _v6Only;
   InternetAddress _boundAddress;
   int _boundPort;
   StreamController<RawSocket> _controller;
   ReceivePort _referencePort;
   Future _scheduledAccept;
   bool _paused = false;
   bool _closed = false;
   var _owner;
 
   static Future<_MojoRawServerSocket> _bind(NetAddress bindAddress,
                                             int backlog,
                                             bool v6Only,
                                             bool shared) async {
     final rawServerSocket = new _MojoRawServerSocket(v6Only);
     final networkService = _getNetworkService();
     assert(networkService != null);
     var response =
         await networkService.createTcpBoundSocket(
             bindAddress,
-            rawServerSocket._tcpBoundSocket);
+            rawServerSocket._tcpBoundSocket.proxy);
     if (!_NetworkService._okay(response.result)) {
       rawServerSocket.close();
       _NetworkService._throwOnError(response.result);
     }
     rawServerSocket._boundAddress =
         _NetworkServiceCodec._fromNetAddress(response.boundTo);
     rawServerSocket._boundPort =
         _NetworkServiceCodec._portFromNetAddress(response.boundTo);
     final boundSocket = rawServerSocket._tcpBoundSocket;
-    response =
-        await boundSocket.startListening(rawServerSocket._tcpServerSocket);
+    response = await boundSocket.startListening(
+        rawServerSocket._tcpServerSocket.proxy);
     if (!_NetworkService._okay(response.result)) {
       rawServerSocket.close();
       _NetworkService._throwOnError(response.result);
     }
     return rawServerSocket;
   }
 
   static Future<_MojoRawServerSocket> bind(address,
                                            int port,
                                            int backlog,
@@ skipping 205 matching lines @@
   int get port => _socket.port;
 
   InternetAddress get address => _socket.address;
 
   Future close() => _socket.close().then((_) => this);
 
   Map _toJSON(bool ref) => _socket._toJSON(ref);
 
   void set _owner(owner) { _socket._owner = owner; }
 }