Add a host script to run in a browser and start iframes for suites.

lib/src/util/multi_channel.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library unittest.multi_channel;
 
 import 'dart:async';
 
+import 'stream_channel.dart';
+
 /// A class that multiplexes multiple virtual channels across a single
 /// underlying transport layer.
 ///
 /// This should be connected to another [MultiChannel] on the other end of the
 /// underlying channel. It starts with a single default virtual channel,
 /// accessible via [stream] and [sink]. Additional virtual channels can be
 /// created with [virtualChannel].
 ///
 /// When a virtual channel is created by one endpoint, the other must connect to
 /// it before messages may be sent through it. The first endpoint passes its
@@ skipping 13 matching lines @@
 ///   // ...
 /// });
 /// ```
 ///
 /// Sending errors across a [MultiChannel] is not supported. Any errors from the
 /// underlying stream will be reported only via the default
 /// [MultiChannel.stream].
 ///
 /// Each virtual channel may be closed individually. When all of them are
 /// closed, the underlying [StreamSink] is closed automatically.
-abstract class MultiChannel {
+abstract class MultiChannel implements StreamChannel {
   /// The default input stream.
   ///
   /// This connects to the remote [sink].
   Stream get stream;
 
   /// The default output stream.
   ///
   /// This connects to the remote [stream]. If this is closed, the remote
   /// [stream] will close, but other virtual channels will remain open and new
   /// virtual channels may be opened.
@@ skipping 17 matching lines @@
   ///
   /// Throws an [ArgumentError] if a virtual channel already exists for [id].
   /// Throws a [StateError] if the underlying channel is closed.
   VirtualChannel virtualChannel([id]);
 }
 
 /// The implementation of [MultiChannel].
 ///
 /// This is private so that [VirtualChannel] can inherit from [MultiChannel]
 /// without having to implement all the private members.
-class _MultiChannel implements MultiChannel {
+class _MultiChannel extends StreamChannelMixin implements MultiChannel {
   /// The inner stream over which all communication is received.
   ///
   /// This will be `null` if the underlying communication channel is closed.
   Stream _innerStream;
 
   /// The inner sink over which all communication is sent.
   ///
   /// This will be `null` if the underlying communication channel is closed.
   StreamSink _innerSink;
 
@@ skipping 125 matching lines @@
       controller.close();
     }
   }
 }
 
 /// A virtual channel created by [MultiChannel].
 ///
 /// This implements [MultiChannel] for convenience.
 /// [VirtualChannel.virtualChannel] is semantically identical to the parent's
 /// [MultiChannel.virtualChannel].
-class VirtualChannel implements MultiChannel {
+class VirtualChannel extends StreamChannelMixin implements MultiChannel {
   /// The [MultiChannel] that created this.
   final MultiChannel _parent;
 
   /// The identifier for this channel.
   ///
   /// This can be sent across the [MultiChannel] to provide the remote endpoint
   /// a means to connect to this channel. Nothing about this is guaranteed
   /// except that it will be JSON-serializable.
   final id;
 
   final Stream stream;
   final StreamSink sink;
 
   VirtualChannel._(this._parent, this.id, this.stream, this.sink);
 
   VirtualChannel virtualChannel([id]) => _parent.virtualChannel(id);
 }