Dart: Refactors Proxies

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 27 matching lines @@
   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().ptr;
+    final networkService = _getNetworkService();
     assert(networkService != null);
     var response =
         await networkService.createTcpBoundSocket(
             bindAddress,
             rawServerSocket._tcpBoundSocket);
     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.ptr;
+    final boundSocket = rawServerSocket._tcpBoundSocket;
     response =
         await boundSocket.startListening(rawServerSocket._tcpServerSocket);
     if (!_NetworkService._okay(response.result)) {
       rawServerSocket.close();
       _NetworkService._throwOnError(response.result);
     }
     return rawServerSocket;
   }
 
   static Future<_MojoRawServerSocket> bind(address,
@@ skipping 23 matching lines @@
     var rawSocket = new _MojoRawSocket();
     rawSocket._localAddress = _boundAddress;
     rawSocket._localPort = _boundPort;
     rawSocket._setupIn();
     rawSocket._setupOut();
     rawSocket._tracePipeIn();
     rawSocket._tracePipeOut();
     var response;
     try {
       response = await _tcpServerSocket.responseOrError(
-          _tcpServerSocket.ptr.accept(rawSocket._pipeOut.consumer,
-                                      rawSocket._pipeIn.producer,
-                                      rawSocket._tcpConnectedSocket));
+          _tcpServerSocket.accept(rawSocket._pipeOut.consumer,
+                                  rawSocket._pipeIn.producer,
+                                  rawSocket._tcpConnectedSocket));
     } on ProxyError catch (e) {
       rawSocket.destroy();
       await _destroy();
       return;
     } catch (e) {
       _controller.addError(e);
       rawSocket.destroy();
       await _destroy();
       return;
     }
@@ skipping 161 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; }
 }