Dart: Adds optional named arguments for creating bindings.

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 114 matching lines @@
 
 abstract class Listener {
   StreamSubscription<List<int>> listen({Function onClosed});
 }
 
 class MojoEventStreamListener {
   MojoMessagePipeEndpoint _endpoint;
   MojoEventStream _eventStream;
   bool _isOpen = false;
   bool _isInHandler = false;
+  StreamSubscription subscription;
 
-  MojoEventStreamListener(MojoMessagePipeEndpoint endpoint)
+  MojoEventStreamListener.fromEndpoint(MojoMessagePipeEndpoint endpoint,
+      {bool doListen: true, Function onClosed})
       : _endpoint = endpoint,
         _eventStream = new MojoEventStream(endpoint.handle),
-        _isOpen = false;
+        _isOpen = false {
+    if (doListen) {
+      listen(onClosed: onClosed);
+    }
+  }
 
-  MojoEventStreamListener.fromHandle(MojoHandle handle) {
+  MojoEventStreamListener.fromHandle(MojoHandle handle,
+    {bool doListen: true, Function onClosed}) {
     _endpoint = new MojoMessagePipeEndpoint(handle);
     _eventStream = new MojoEventStream(handle);
     _isOpen = false;
+    if (doListen) {
+      listen(onClosed: onClosed);
+    }
   }
 
   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}) {
+    assert(isBound && (subscription == null));
     _isOpen = true;
-    return _eventStream.listen((List<int> event) {
+    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();
         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();
       }
       if (signalsReceived.isWritable) {
         assert(_eventStream.readyWrite);
         handleWrite();
       }
       if (_isOpen) {
         _eventStream.enableSignals(signalsWatched);
       }
       _isInHandler = false;
     }, 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;
 }