Dart: Removes need to call listen().

mojo/public/dart/src/event_stream.dart

Index: mojo/public/dart/src/event_stream.dart
diff --git a/mojo/public/dart/src/event_stream.dart b/mojo/public/dart/src/event_stream.dart
index c1251140acaaefd870bf0e18085337e16cf8a879..7643ac71c7ed8bb4bcd21032b56cd41219e15c27 100644
--- a/mojo/public/dart/src/event_stream.dart
+++ b/mojo/public/dart/src/event_stream.dart
@@ -123,9 +123,7 @@ class MojoEventStream extends Stream<List<int>> {
   String toString() => "$_handle";
 }
 
-abstract class Listener {
-  StreamSubscription<List<int>> listen({Function onClosed});
-}
+typedef void ErrorHandler();
 
 class MojoEventStreamListener {
   MojoMessagePipeEndpoint _endpoint;
@@ -133,25 +131,20 @@ class MojoEventStreamListener {
   bool _isOpen = false;
   bool _isInHandler = false;
   StreamSubscription subscription;
+  ErrorHandler onError;
 
-  MojoEventStreamListener.fromEndpoint(MojoMessagePipeEndpoint endpoint,
-      {bool doListen: true, Function onClosed})
+  MojoEventStreamListener.fromEndpoint(MojoMessagePipeEndpoint endpoint)

[hansmuller1, 2015/03/06 17:12:38]

We've run into the need for |doListen: false| when the implementation of a
stub isn't available when the stub is created from an endpoint.

class Bar {
  final FooStub _stub;
  Bar(MojoMessagePipeEndpoint endpoint)
      : _stub = new FooStub.fromEndpoint(endpoint, doListen: false);
  void set foo(Foo impl) {
    _stub.impl = impl;
    _stub.listen();
  }
}

The problem can be avoided by creating _stub lazily, however then 
it must be a read/write member.

It also comes up in a more idiomatic use case, since one can't refer
to |this| in an initializer:

class FooImpl implements Foo {
  final FooStub _stub;
  FooImpl(MojoMessagePipeEndpoint endpoint)
      : _stub = new FooStub.fromEndpoint(endpoint, doListen: false) {
    _stub.impl = this;
    _stub.listen();
  }
}

The idiomatic case can be rewritten easily enough, by removing the 
final qualifier and initializing _stub in the constructor:

class FooImpl implements Foo {
  FooStub _stub;
  FooImpl(MojoMessagePipeEndpoint endpoint) {
    _stub = new FooStub.fromEndpoint(endpoint, impl) {
  }
}

Unfortunately (as before) this leaves _stub as a read/write member,
which isn't what's intended.

[zra, 2015/03/06 21:12:00]

Scott pointed out that it is okay to wait to set impl until after the listen()
so long as impl is set before execution returns to the event loop. If that
sounds too error-prone or not flexible enough, I can add back the doListen.
Also, in this CL, the impl argument to the Stub constructor is optional, so the
_stub fields could still be final, you just set the impl in the constructor as
before.

Let me know how you and Scott would like to go with the doListen parameter.
Either way, it's not hard to change back after getting more experience.

       : _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()
@@ -173,7 +166,7 @@ class MojoEventStreamListener {
     _isOpen = false;
   }
 
-  StreamSubscription<List<int>> listen({Function onClosed}) {
+  StreamSubscription<List<int>> listen() {
     assert(isBound && (subscription == null));
     _isOpen = true;
     subscription = _eventStream.listen((List<int> event) {
@@ -193,7 +186,7 @@ class MojoEventStreamListener {
       }
       _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.