Dart: Encode/Decode handle and interface types.

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<int> {
   // The underlying Mojo handle.
   MojoHandle _handle;
 
@@ skipping 104 matching lines @@
   bool get readyRead => _handle.readyRead;
   bool get readyWrite => _handle.readyWrite;
 
   String toString() => "$_handle";
 }
 
 
 class MojoEventStreamListener {
   MojoMessagePipeEndpoint _endpoint;
   MojoEventStream _eventStream;
-  bool _isOpen;
-  bool _isInHandler;
+  bool _isOpen = false;
+  bool _isInHandler = false;
 
   MojoEventStreamListener(MojoMessagePipeEndpoint endpoint) :
       _endpoint = endpoint,
       _eventStream = new MojoEventStream(endpoint.handle),
       _isOpen = false;
 
-  MojoEventStreamListener.fromHandle(int handle) {
-    _endpoint = new MojoMessagePipeEndpoint(new MojoHandle(handle));
-    _eventStream = new MojoEventStream(_endpoint.handle);
+  MojoEventStreamListener.fromHandle(MojoHandle handle) {
+    _endpoint = new MojoMessagePipeEndpoint(handle);
+    _eventStream = new MojoEventStream(handle);
     _isOpen = false;
   }
 
+  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<int> listen() {
     _isOpen = true;
     return _eventStream.listen((List<int> event) {
       var signalsWatched = new MojoHandleSignals(event[0]);
       var signalsReceived = new MojoHandleSignals(event[1]);
       if (signalsReceived.isPeerClosed) {
         handlePeerClosed();
         // 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.
@@ skipping 12 matching lines @@
           signalsWatched, signalsReceived));
       _isInHandler = false;
     });
   }
 
   void close() {
     if (_isOpen) {
       _eventStream.close();
       _isOpen = false;
       _eventStream = null;
+      _endpoint = null;
     }
   }
 
   void handleRead() {}
   void handleWrite() {}
   void handlePeerClosed() {
     close();
   }
 
   MojoHandleSignals enableSignals(MojoHandleSignals watched,
                                   MojoHandleSignals received) => watched;
 
   MojoMessagePipeEndpoint get endpoint => _endpoint;
   bool get isOpen => _isOpen;
   bool get isInHandler => _isInHandler;
+  bool get isBound => _endpoint != null;
 }