Dart: Use a RawReceivePort to receive events for Mojo handles.

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 31 matching lines @@
 // * 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 {
   final Application _application;
   files.FileProxy _terminal;
   TcpConnectedSocketProxy _socket;
   MojoDataPipeProducer _socketSender;
   MojoDataPipeConsumer _socketReceiver;
-  MojoEventStream _socketReceiverEventStream;
+  MojoEventHandler _socketReceiverEventHandler;
   final ByteData _readBuffer;
   final ByteData _writeBuffer;
 
   // TODO(vtl): Don't just hard-code buffer sizes.
   Connector(this._application, this._terminal)
       : _readBuffer = new ByteData(16 * 1024),
         _writeBuffer = new ByteData(16 * 1024);
 
   Future connect(NetAddress remote_address) async {
     try {
@@ skipping 11 matching lines @@
       _socketReceiver = receiveDataPipe.consumer;
       _socket = new TcpConnectedSocketProxy.unbound();
       await boundSocket.ptr.connect(remote_address, sendDataPipe.consumer,
           receiveDataPipe.producer, _socket);
       await boundSocket.close();
 
       // Set up reading from the terminal.
       _startReadingFromTerminal();
 
       // Set up reading from the socket.
-      _socketReceiverEventStream = new MojoEventStream(_socketReceiver.handle);
-      _socketReceiverEventStream.listen(_onSocketReceiverEvent);
+      _socketReceiverEventHandler = new MojoEventHandler(_socketReceiver.handle);
+      _socketReceiverEventHandler.handleEvents(_onSocketReceiverEvent);
     } catch (e) {
       _shutDown();
     }
   }
 
   void _startReadingFromTerminal() {
     // TODO(vtl): Do we have to do something on error?
     _terminal.ptr
         .read(_writeBuffer.lengthInBytes, 0, files.Whence.FROM_CURRENT)
         .then(_onReadFromTerminal)
@@ skipping 27 matching lines @@
   void _onSocketReceiverEvent(List<int> event) {
     var mojoSignals = new MojoHandleSignals(event[1]);
     var shouldShutDown = false;
     if (mojoSignals.isReadable) {
       var numBytesRead = _socketReceiver.read(_readBuffer);
       if (_socketReceiver.status.isOk) {
         assert(numBytesRead > 0);
         _terminal.ptr.write(_readBuffer.buffer.asUint8List(0, numBytesRead), 0,
                             files.Whence.FROM_CURRENT)
             .catchError((e) { _shutDown(); });
-        _socketReceiverEventStream.enableReadEvents();
+        _socketReceiverEventHandler.enableReadEvents();
       } else {
         shouldShutDown = true;
       }
     } else if (mojoSignals.isPeerClosed) {
       shouldShutDown = true;
     } else {
       throw 'Unexpected handle event: $mojoSignals';
     }
     if (shouldShutDown) {
       _shutDown();
     }
   }
 
   void _shutDown() {
-    if (_socketReceiverEventStream != null) {
-      ignoreFuture(_socketReceiverEventStream.close());
-      _socketReceiverEventStream = null;
+    if (_socketReceiverEventHandler != null) {
+      ignoreFuture(_socketReceiverEventHandler.close());
+      _socketReceiverEventHandler = null;
     }
     if (_socketSender != null) {
       if (_socketSender.handle.isValid)
         _socketSender.handle.close();
       _socketSender = null;
     }
     if (_socketReceiver != null) {
       if (_socketReceiver.handle.isValid)
         _socketReceiver.handle.close();
       _socketReceiver = null;
@@ skipping 58 matching lines @@
       ApplicationConnection connection) {
     connection.provideService(TerminalClientName,
         (endpoint) => new TerminalClientImpl(this, resolvedUrl, endpoint));
   }
 }
 
 main(List args) {
   MojoHandle appHandle = new MojoHandle(args[0]);
   String url = args[1];
   new NetcatApplication.fromHandle(appHandle)
-    ..onError = (() {
+    ..onError = ((Object e) {
       MojoHandle.reportLeakedHandles();
     });
 }