Dart: Futures -> Callbacks.

examples/dart/netcat/lib/main.dart

 #!mojo mojo:dart_content_handler
 // Copyright 2014 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.
 
 import 'dart:async';
 import 'dart:core';
 import 'dart:typed_data';
 
 import 'package:mojo/application.dart';
@@ skipping 15 matching lines @@
 NetAddress makeIPv4NetAddress(List<int> addr, int port) {
   var rv = new NetAddress();
   rv.family = NetAddressFamily.ipv4;
   rv.ipv4 = new NetAddressIPv4();
   rv.ipv4.addr = new List<int>.from(addr);
   rv.ipv4.port = port;
   return rv;
 }
 
 void fputs(files.File f, String s) {
-  ignoreFuture(f.write((s + '\n').codeUnits, 0, files.Whence.fromCurrent));
+  f.write((s + '\n').codeUnits, 0, files.Whence.fromCurrent, (e, n) {});
 }
 
 // Connects the terminal |File| and the socket.
 // TODO(vtl):
 // * Error handling: both connection/socket errors and terminal errors.
 // * Relatedly, we should listen for _socketSender's peer being closed (also
 //   _socket, I guess).
 // * Handle the socket send pipe being full (currently, we assume it's never
 //   full).
 class Connector {
@@ skipping 11 matching lines @@
       : _readBuffer = new ByteData(16 * 1024),
         _writeBuffer = new ByteData(16 * 1024);
 
   Future connect(NetAddress remote_address) async {
     try {
       var networkService = new NetworkServiceProxy.unbound();
       _application.connectToService('mojo:network_service', networkService);
 
       NetAddress local_address = makeIPv4NetAddress([0, 0, 0, 0], 0);
       var boundSocket = new TcpBoundSocketProxy.unbound();
-      await networkService.createTcpBoundSocket(local_address, boundSocket);
+      var c = new Completer();
+      networkService.createTcpBoundSocket(local_address, boundSocket, (_) {
+        c.complete(null);
+      });
+      await networkService.responseOrError(c.future);
       await networkService.close();
 
       var sendDataPipe = new MojoDataPipe();
       _socketSender = sendDataPipe.producer;
       var receiveDataPipe = new MojoDataPipe();
       _socketReceiver = receiveDataPipe.consumer;
       _socket = new TcpConnectedSocketProxy.unbound();
-      await boundSocket.connect(remote_address, sendDataPipe.consumer,
-          receiveDataPipe.producer, _socket);
+      c = new Completer();
+      boundSocket.connect(remote_address, sendDataPipe.consumer,
+          receiveDataPipe.producer, _socket, (_) {
+        c.complete(null);
+      });
+      await boundSocket.responseOrError(c.future);
       await boundSocket.close();
 
       // Set up reading from the terminal.
       _startReadingFromTerminal();
 
       // Set up reading from the socket.
       _socketReceiverEventSubscription =
           new MojoEventSubscription(_socketReceiver.handle);
       _socketReceiverEventSubscription.subscribe(_onSocketReceiverEvent);
     } catch (e) {
       _shutDown();
     }
   }
 
   void _startReadingFromTerminal() {
     // TODO(vtl): Do we have to do something on error?
-    _terminal
-        .read(_writeBuffer.lengthInBytes, 0, files.Whence.fromCurrent)
-        .then(_onReadFromTerminal)
-        .catchError((e) {
+    var c = new Completer();
+    _terminal.read(
+        _writeBuffer.lengthInBytes, 0,
+        files.Whence.fromCurrent, (error, bytes) {
+      _onReadFromTerminal(error, bytes);
+      c.complete(null);
+    });
+    _terminal.responseOrError(c.future).catchError((_) {
       _shutDown();
     });
   }
 
-  void _onReadFromTerminal(files.FileReadResponseParams p) {
-    if (p.error != files.Error.ok) {
+  void _onReadFromTerminal(files.Error error, List<int> bytesRead) {
+    if (error != files.Error.ok) {
       // TODO(vtl): Do terminal errors.
       return;
     }
 
     // TODO(vtl): Verify that |bytesRead.length| is within the expected range.
-    for (var i = 0, j = 0; i < p.bytesRead.length; i++, j++) {
+    for (var i = 0, j = 0; i < bytesRead.length; i++, j++) {
       // TODO(vtl): Temporary hack: Translate \r to \n, since we don't have
       // built-in support for that.
-      if (p.bytesRead[i] == 13) {
+      if (bytesRead[i] == 13) {
         _writeBuffer.setUint8(i, 10);
       } else {
-        _writeBuffer.setUint8(i, p.bytesRead[i]);
+        _writeBuffer.setUint8(i, bytesRead[i]);
       }
     }
 
     // TODO(vtl): Handle the send data pipe being full (or closed).
     _socketSender
-        .write(new ByteData.view(_writeBuffer.buffer, 0, p.bytesRead.length));
+        .write(new ByteData.view(_writeBuffer.buffer, 0, bytesRead.length));
 
     _startReadingFromTerminal();
   }
 
   void _onSocketReceiverEvent(int mojoSignals) {
     var shouldShutDown = false;
     if (MojoHandleSignals.isReadable(mojoSignals)) {
       var numBytesRead = _socketReceiver.read(_readBuffer);
       if (_socketReceiver.status == MojoResult.kOk) {
         assert(numBytesRead > 0);
-        _terminal
-            .write(_readBuffer.buffer.asUint8List(0, numBytesRead), 0,
-                files.Whence.fromCurrent)
-            .catchError((e) {
+        var c = new Completer();
+        _terminal.write(_readBuffer.buffer.asUint8List(0, numBytesRead), 0,
+            files.Whence.fromCurrent, (e, n) {
+          c.complete(null);
+        });
+        _terminal.responseOrError(c.future).catchError((_) {
           _shutDown();
         });
         _socketReceiverEventSubscription.enableReadEvents();
       } else {
         shouldShutDown = true;
       }
     } else if (MojoHandleSignals.isPeerClosed(mojoSignals)) {
       shouldShutDown = true;
     } else {
       String signals = MojoHandleSignals.string(mojoSignals);
@@ skipping 86 matching lines @@
   }
 }
 
 main(List args, Object handleToken) {
   MojoHandle appHandle = new MojoHandle(handleToken);
   new NetcatApplication.fromHandle(appHandle)
     ..onError = ((Object e) {
       MojoHandle.reportLeakedHandles();
     });
 }