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 106 matching lines @@
     }
   }
 
   bool get readyRead => _handle.readyRead;
   bool get readyWrite => _handle.readyWrite;
 
   String toString() => "$_handle";
 }
 
 abstract class Listener {
-  StreamSubscription<List<int>> listen({Function onClosed});
+  StreamSubscription<List<int>> listen();
 }
 
 class MojoEventStreamListener {
   MojoMessagePipeEndpoint _endpoint;
   MojoEventStream _eventStream;
   bool _isOpen = false;
   bool _isInHandler = false;
   StreamSubscription subscription;
+  Function _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]);
       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;
       }
       _isInHandler = true;
       if (signalsReceived.isReadable) {
         assert(_eventStream.readyRead);
         handleRead();
@@ skipping 16 matching lines @@
     subscription = null;
     if (_eventStream != null) {
       _eventStream.close();
       _eventStream = null;
     }
   }
 
   void handleRead() {}
   void handleWrite() {}
 
+  Function get onError => _onError;
+           set onError(Function f) {
+    if (f == null) {
+      _onError = null;
+    } else {
+      Function cachedOnError = _onError;

[hansmuller1, 2015/03/05 00:35:32]

Why are we accumulating onError functions here? Developers who really want to
wrap the value of onError can easily do so, doing it automatically seems like it
would lead to confusion.

[zra, 2015/03/05 16:39:29]

I was worried about people accidentally overwriting the onError callbacks added
for closing ApplicationConnection and LocalServiceProvider, but I can try to
work around that a different way. I'll write it up and see what it looks like.

+      _onError = (() {
+        if (cachedOnError != null) {
+          cachedOnError();
+        }
+        f();
+      });
+    }
+  }
+
   MojoMessagePipeEndpoint get endpoint => _endpoint;
   bool get isOpen => _isOpen;
   bool get isInHandler => _isInHandler;
   bool get isBound => _endpoint != null;
 }