Dart: Futures -> Callbacks.

mojo/dart/embedder/io/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 Socket and RawSocket for Mojo.
 //
 
 patch class Socket {
   /* patch */ static Future<Socket> connect(host, int port, {sourceAddress}) {
     return RawSocket.connect(host, port, sourceAddress: sourceAddress).then(
         (socket) => new _MojoSocket(socket));
   }
 }
 
 patch class RawSocket {
   /* patch */ static Future<RawSocket> connect(
       host, int port, {sourceAddress}) {
     return _MojoRawSocket.connect(host, port, sourceAddress);
   }
 }
 
 class _MojoRawSocket extends Stream<RawSocketEvent> implements RawSocket {
   StreamController<RawSocketEvent> _controller;
-  final _tcpBoundSocket = new TcpBoundSocketProxy.unbound();
+  final _tcpBoundSocket = new _TcpBoundSocketProxy.unbound();
   final _tcpConnectedSocket = new TcpConnectedSocketProxy.unbound();
   // Constructing a new MojoDataPipe allocates two handles. All failure paths
   // must be sure that these handles are closed so we do not leak any handles.
   final _pipeOut = new MojoDataPipe();
   bool _outClosed = false;
   // Constructing a new MojoDataPipe allocates two handles. All failure paths
   // must be sure that these handles are closed so we do not leak any handles.
   final _pipeIn = new MojoDataPipe();
   bool _inClosed = false;
   bool _readEventsEnabled = true;
@@ skipping 11 matching lines @@
 
   _tracePrint(String message) {
     assert(_trace);
     print('${_traceId}: $message');
   }
 
   _traceProxies() {
     if (!_trace) {
       return;
     }
-    _tracePrint('_tcpBoundSocket handle = ${_tcpBoundSocket.handle}');
-    _tracePrint('_tcpConnectedSocket handle = ${_tcpConnectedSocket.handle}');
+    _tracePrint(
+        '_tcpBoundSocket handle = ${_tcpBoundSocket.proxy.handle}');
+    _tracePrint(
+        '_tcpConnectedSocket handle = ${_tcpConnectedSocket.handle}');
   }
 
   _tracePipeIn() {
     if (!_trace) {
       return;
     }
     if (_pipeInEvents != null) {
       _tracePrint('pipe in consumer handle = ${_pipeInEvents.handle}');
     } else {
       _tracePrint('pipe in consumer handle ${_pipeIn.consumer.handle}');
@@ skipping 48 matching lines @@
     if (!_trace) {
       return;
     }
     _tracePrint(_tcpConnectedSocket.toString());
   }
 
   _traceBoundSocket() {
     if (!_trace) {
       return;
     }
-    _tracePrint(_tcpBoundSocket.toString());
+    _tracePrint(_tcpBoundSocket.proxy.toString());
   }
 
   static int _traceIdGenerator = 0;
   static _enableTrace(_MojoRawSocket rawSocket) {
     if (rawSocket._trace) {
       return;
     }
     rawSocket._trace = true;
     rawSocket._traceId = _traceIdGenerator++;
     rawSocket._tracePrint('Tracing enabled for ${rawSocket._traceId}');
     rawSocket._traceLocalAddress();
     rawSocket._traceRemoteAddress();
   }
 
   _MojoRawSocket() {
     _controller = new StreamController(sync: true,
                                        onListen: _onSubscriptionStateChange,
                                        onCancel: _onSubscriptionStateChange,
                                        onPause: _onPauseStateChange,
                                        onResume: _onPauseStateChange);
   }
 
   static Future<_MojoRawSocket> _connect(NetAddress source,
                                          NetAddress dest) async {
     var rawSocket = new _MojoRawSocket();
     var networkService = _getNetworkService();
     assert(networkService != null);
-    var response =
-        await networkService.createTcpBoundSocket(source,
-                                                  rawSocket._tcpBoundSocket);
+    var response = await networkService.createTcpBoundSocket(
+        source, rawSocket._tcpBoundSocket.proxy);
     if (!_NetworkService._okay(response.result)) {
       rawSocket.close();
       _NetworkService._throwOnError(response.result);
     }
 
     rawSocket._traceBoundSocket();
 
     rawSocket._localAddress =
         _NetworkServiceCodec._fromNetAddress(response.boundTo);
     rawSocket._localPort =
@@ skipping 640 matching lines @@
       if (_raw != null) {
         _raw.shutdown(SocketDirection.SEND);
         _disableWriteEvent();
       }
     }
   }
 
   Map _toJSON(bool ref) => _raw._toJSON(ref);
   void set _owner(owner) { _raw._owner = owner; }
 }