Provide mechanism to close immediately to Dart 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 19 matching lines @@
       [MojoHandleSignals signals = MojoHandleSignals.PEER_CLOSED_READABLE])
       : _handle = handle,
         _signals = signals,
         _isListening = false {
     MojoResult result = MojoHandle.register(this);
     if (!result.isOk) {
       throw "Failed to register the MojoHandle: $result.";
     }
   }
 
-  Future close() {
+  Future close({bool immediate: false}) {
     if (_handle != null) {
       if (_isListening) {
-        return _handleWatcherClose();
+        return _handleWatcherClose(immediate: immediate);
       } else {
         _localClose();
         return new Future.value(null);
       }
     }
   }
 
   StreamSubscription<List<int>> listen(void onData(List event),
       {Function onError, void onDone(), bool cancelOnError}) {
     if (_isListening) {
@@ skipping 31 matching lines @@
         throw "MojoHandleWatcher add failed: $res";
       }
     }
   }
 
   void enableReadEvents() =>
       enableSignals(MojoHandleSignals.PEER_CLOSED_READABLE);
   void enableWriteEvents() => enableSignals(MojoHandleSignals.WRITABLE);
   void enableAllEvents() => enableSignals(MojoHandleSignals.READWRITE);
 
-  Future _handleWatcherClose() {
+  Future _handleWatcherClose({bool immediate: false}) {
     assert(_handle != null);
     assert(MojoHandle._removeUnclosedHandle(_handle));
-    return MojoHandleWatcher.close(_handle.h, wait: true).then((r) {
+    return MojoHandleWatcher.close(_handle.h, wait: !immediate).then((r) {
       if (_receivePort != null) {
         _receivePort.close();
         _receivePort = null;
       }
       return new MojoResult(r);
     });
   }
 
   void _localClose() {
     assert(_handle != null);
     _handle.close();
     _handle = null;
     if (_receivePort != null) {
       _receivePort.close();
       _receivePort = null;
     }
   }
 
   void _onSubscriptionStateChange() {
     if (!_controller.hasListener) {
-      close();
+      // No one is listening, close it immediately.
+      close(immediate: true);
     }
   }
 
   void _onPauseStateChange() {
     if (_controller.isPaused) {
       var res = new MojoResult(MojoHandleWatcher.remove(_handle.h));
       if (!res.isOk) {
         throw "MojoHandleWatcher add failed: $res";
       }
     } else {
@@ skipping 73 matching lines @@
       }
       if (signalsReceived.isWritable) {
         assert(_eventStream.readyWrite);
         handleWrite();
       }
       if (!signalsReceived.isPeerClosed) {
         _eventStream.enableSignals(signalsWatched);
       }
       _isInHandler = false;
       if (signalsReceived.isPeerClosed) {
-        // nodefer is true here because there is no need to wait to close until
-        // outstanding messages are sent. The other side is gone.
-        close(nodefer: true).then((_) {
+        // immediate is true here because there is no need to wait to close
+        // until outstanding messages are sent. The other side is gone.
+        close(immediate: true).then((_) {
           if (onError != null) {
             onError();
           }
         });
       }
     }, onDone: close);
     return subscription;
   }
 
-  Future close({bool nodefer: false}) {
+  Future close({bool immediate: false}) {
     var result;
     _isOpen = false;
     _endpoint = null;
     subscription = null;
     if (_eventStream != null) {
-      result = _eventStream.close().then((_) {
+      result = _eventStream.close(immediate: immediate).then((_) {
         _eventStream = null;
       });
     }
     return result != null ? result : new Future.value(null);
   }
 
   void handleRead() {}
   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)";
 }