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 105 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)

[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()
       : _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;
   }
 
   void close() {
     _isOpen = false;
     _endpoint = null;
     subscription = null;
     if (_eventStream != null) {
       _eventStream.close();
       _eventStream = null;
     }
   }
 
   void handleRead() {}
   void handleWrite() {}
 
   MojoMessagePipeEndpoint get endpoint => _endpoint;
   bool get isOpen => _isOpen;
   bool get isInHandler => _isInHandler;
   bool get isBound => _endpoint != null;
 }