Dart: Removes need to call listen().

mojo/public/dart/src/event_stream.dart

 // 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.
 
 part of core;
 
 class MojoEventStream extends Stream<List<int>> {
   // The underlying Mojo handle.
   MojoHandle _handle;
 
@@ skipping 102 matching lines @@
       }
     }
   }
 
   bool get readyRead => _handle.readyRead;
   bool get readyWrite => _handle.readyWrite;
 
   String toString() => "$_handle";
 }
 
-abstract class Listener {
-  StreamSubscription<List<int>> listen({Function onClosed});
-}
+typedef void ErrorHandler();
 
 class MojoEventStreamListener {
   MojoMessagePipeEndpoint _endpoint;
   MojoEventStream _eventStream;
   bool _isOpen = false;
   bool _isInHandler = false;
   StreamSubscription subscription;
+  ErrorHandler onError;
 
-  MojoEventStreamListener.fromEndpoint(MojoMessagePipeEndpoint endpoint,
-      {bool doListen: true, Function onClosed})
+  MojoEventStreamListener.fromEndpoint(MojoMessagePipeEndpoint endpoint)
       : _endpoint = endpoint,
         _eventStream = new MojoEventStream(endpoint.handle),
         _isOpen = false {
-    if (doListen) {
-      listen(onClosed: onClosed);
-    }
+    listen();
   }
 
-  MojoEventStreamListener.fromHandle(MojoHandle handle,
-      {bool doListen: true, Function onClosed}) {
+  MojoEventStreamListener.fromHandle(MojoHandle handle) {
     _endpoint = new MojoMessagePipeEndpoint(handle);
     _eventStream = new MojoEventStream(handle);
     _isOpen = false;
-    if (doListen) {
-      listen(onClosed: onClosed);
-    }
+    listen();
   }
 
   MojoEventStreamListener.unbound()
       : _endpoint = null,
         _eventStream = null,
         _isOpen = false;
 
   void bind(MojoMessagePipeEndpoint endpoint) {
     assert(!isBound);
     _endpoint = endpoint;
     _eventStream = new MojoEventStream(endpoint.handle);
     _isOpen = false;
   }
 
   void bindFromHandle(MojoHandle handle) {
     assert(!isBound);
     _endpoint = new MojoMessagePipeEndpoint(handle);
     _eventStream = new MojoEventStream(handle);
     _isOpen = false;
   }
 
-  StreamSubscription<List<int>> listen({Function onClosed}) {
+  StreamSubscription<List<int>> listen() {
     assert(isBound && (subscription == null));
     _isOpen = true;
     subscription = _eventStream.listen((List<int> event) {
       var signalsWatched = new MojoHandleSignals(event[0]);
       var signalsReceived = new MojoHandleSignals(event[1]);
       _isInHandler = true;
       if (signalsReceived.isReadable) {
         assert(_eventStream.readyRead);
         handleRead();
       }
       if (signalsReceived.isWritable) {
         assert(_eventStream.readyWrite);
         handleWrite();
       }
       if (_isOpen) {
         _eventStream.enableSignals(signalsWatched);
       }
       _isInHandler = false;
       if (signalsReceived.isPeerClosed) {
-        if (onClosed != null) onClosed();
+        if (onError != null) onError();
         close();
         // The peer being closed obviates any other signal we might
         // have received since we won't be able to read or write the handle.
         // Thus, we just return before invoking other handlers.
         return;
       }
     }, onDone: close);
     return subscription;
   }
 
@@ skipping 11 matching lines @@
   void handleWrite() {}
 
   MojoMessagePipeEndpoint get endpoint => _endpoint;
   bool get isOpen => _isOpen;
   bool get isInHandler => _isInHandler;
   bool get isBound => _endpoint != null;
 
   String toString() => "MojoEventStreamListener("
       "isOpen: $isOpen, isBound: $isBound, endpoint: $_endpoint)";
 }