diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..328e779
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,16 @@
+## 0.0.2+3
+
+* Fix a library name conflict.
+
+## 0.0.2+2
+
+* Fixes for HTTP date formatting.
+
+## 0.0.2+1
+
+* Minor code refactoring.
+
+## 0.0.2
+
+* Added `CompatibleWebSocket`, for platform- and API-independent support for the
+  WebSocket API.
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..5c60afe
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,26 @@
+Copyright 2014, the Dart project authors. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google Inc. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..edfa71a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,3 @@
+`http_parser` is a platform-independent package for parsing and serializing
+various HTTP-related formats. It's designed to be usable on both the browser and
+the server, and thus avoids referencing any types from `dart:io` or `dart:html`.
diff --git a/lib/http_parser.dart b/lib/http_parser.dart
new file mode 100644
index 0000000..0aa9cea
--- /dev/null
+++ b/lib/http_parser.dart
@@ -0,0 +1,9 @@
+// Copyright (c) 2014, 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 http_parser;
+
+export 'src/http_date.dart';
+export 'src/media_type.dart';
+export 'src/web_socket.dart';
diff --git a/lib/src/bytes_builder.dart b/lib/src/bytes_builder.dart
new file mode 100644
index 0000000..446e175
--- /dev/null
+++ b/lib/src/bytes_builder.dart
@@ -0,0 +1,214 @@
+// Copyright (c) 2013, 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.
+
+// This is a copy of "dart:io"'s BytesBuilder implementation, from
+// sdk/lib/io/bytes_builder.dart. It's copied here to make it available to
+// non-"dart:io" applications (issue 18348).
+//
+// Because it's copied directly, there are no modifications from the original.
+library http_parser.bytes_builder;
+
+import 'dart:math';
+import 'dart:typed_data';
+
+/**
+ * Builds a list of bytes, allowing bytes and lists of bytes to be added at the
+ * end.
+ *
+ * Used to efficiently collect bytes and lists of bytes.
+ */
+abstract class BytesBuilder {
+  /**
+   * Construct a new empty [BytesBuilder].
+   *
+   * If [copy] is true, the data is always copied when added to the list. If
+   * it [copy] is false, the data is only copied if needed. That means that if
+   * the lists are changed after added to the [BytesBuilder], it may effect the
+   * output. Default is `true`.
+   */
+  factory BytesBuilder({bool copy: true}) {
+    if (copy) {
+      return new _CopyingBytesBuilder();
+    } else {
+      return new _BytesBuilder();
+    }
+  }
+
+  /**
+   * Appends [bytes] to the current contents of the builder.
+   *
+   * Each value of [bytes] will be bit-representation truncated to the range
+   * 0 .. 255.
+   */
+  void add(List<int> bytes);
+
+  /**
+   * Append [byte] to the current contents of the builder.
+   *
+   * The [byte] will be bit-representation truncated to the range 0 .. 255.
+   */
+  void addByte(int byte);
+
+  /**
+   * Returns the contents of `this` and clears `this`.
+   *
+   * The list returned is a view of the the internal buffer, limited to the
+   * [length].
+   */
+  List<int> takeBytes();
+
+  /**
+   * Returns a copy of the current contents of the builder.
+   *
+   * Leaves the contents of the builder intact.
+   */
+  List<int> toBytes();
+
+  /**
+   * The number of bytes in the builder.
+   */
+  int get length;
+
+  /**
+   * Returns `true` if the buffer is empty.
+   */
+  bool get isEmpty;
+
+  /**
+   * Returns `true` if the buffer is not empty.
+   */
+  bool get isNotEmpty;
+
+  /**
+   * Clear the contents of the builder.
+   */
+  void clear();
+}
+
+
+class _CopyingBytesBuilder implements BytesBuilder {
+  // Start with 1024 bytes.
+  static const int _INIT_SIZE = 1024;
+
+  int _length = 0;
+  Uint8List _buffer;
+
+  void add(List<int> bytes) {
+    int bytesLength = bytes.length;
+    if (bytesLength == 0) return;
+    int required = _length + bytesLength;
+    if (_buffer == null) {
+      int size = _pow2roundup(required);
+      size = max(size, _INIT_SIZE);
+      _buffer = new Uint8List(size);
+    } else if (_buffer.length < required) {
+      // We will create a list in the range of 2-4 times larger than
+      // required.
+      int size = _pow2roundup(required) * 2;
+      var newBuffer = new Uint8List(size);
+      newBuffer.setRange(0, _buffer.length, _buffer);
+      _buffer = newBuffer;
+    }
+    assert(_buffer.length >= required);
+    if (bytes is Uint8List) {
+      _buffer.setRange(_length, required, bytes);
+    } else {
+      for (int i = 0; i < bytesLength; i++) {
+        _buffer[_length + i] = bytes[i];
+      }
+    }
+    _length = required;
+  }
+
+  void addByte(int byte) => add([byte]);
+
+  List<int> takeBytes() {
+    if (_buffer == null) return new Uint8List(0);
+    var buffer = new Uint8List.view(_buffer.buffer, 0, _length);
+    clear();
+    return buffer;
+  }
+
+  List<int> toBytes() {
+    if (_buffer == null) return new Uint8List(0);
+    return new Uint8List.fromList(
+        new Uint8List.view(_buffer.buffer, 0, _length));
+  }
+
+  int get length => _length;
+
+  bool get isEmpty => _length == 0;
+
+  bool get isNotEmpty => _length != 0;
+
+  void clear() {
+    _length = 0;
+    _buffer = null;
+  }
+
+  int _pow2roundup(int x) {
+    --x;
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+    return x + 1;
+  }
+}
+
+
+class _BytesBuilder implements BytesBuilder {
+  int _length = 0;
+  final List _chunks = [];
+
+  void add(List<int> bytes) {
+    if (bytes is! Uint8List) {
+      bytes = new Uint8List.fromList(bytes);
+    }
+    _chunks.add(bytes);
+    _length += bytes.length;
+  }
+
+  void addByte(int byte) => add([byte]);
+
+  List<int> takeBytes() {
+    if (_chunks.length == 0) return new Uint8List(0);
+    if (_chunks.length == 1) {
+      var buffer = _chunks.single;
+      clear();
+      return buffer;
+    }
+    var buffer = new Uint8List(_length);
+    int offset = 0;
+    for (var chunk in _chunks) {
+      buffer.setRange(offset, offset + chunk.length, chunk);
+      offset += chunk.length;
+    }
+    clear();
+    return buffer;
+  }
+
+  List<int> toBytes() {
+    if (_chunks.length == 0) return new Uint8List(0);
+    var buffer = new Uint8List(_length);
+    int offset = 0;
+    for (var chunk in _chunks) {
+      buffer.setRange(offset, offset + chunk.length, chunk);
+      offset += chunk.length;
+    }
+    return buffer;
+  }
+
+  int get length => _length;
+
+  bool get isEmpty => _length == 0;
+
+  bool get isNotEmpty => _length != 0;
+
+  void clear() {
+    _length = 0;
+    _chunks.clear();
+  }
+}
diff --git a/lib/src/http_date.dart b/lib/src/http_date.dart
new file mode 100644
index 0000000..0626c72
--- /dev/null
+++ b/lib/src/http_date.dart
@@ -0,0 +1,152 @@
+// Copyright (c) 2014, 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 http_parser.http_date;
+
+import 'package:string_scanner/string_scanner.dart';
+
+const _WEEKDAYS = const ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+const _MONTHS = const ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
+    "Sep", "Oct", "Nov", "Dec"];
+
+final _shortWeekdayRegExp = new RegExp(r"Mon|Tue|Wed|Thu|Fri|Sat|Sun");
+final _longWeekdayRegExp =
+    new RegExp(r"Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday");
+final _monthRegExp =
+    new RegExp(r"Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec");
+final _digitRegExp = new RegExp(r"\d+");
+
+/// Return a HTTP-formatted string representation of [date].
+///
+/// This follows [RFC 822](http://tools.ietf.org/html/rfc822) as updated by [RFC
+/// 1123](http://tools.ietf.org/html/rfc1123).
+String formatHttpDate(DateTime date) {
+  date = date.toUtc();
+  var buffer = new StringBuffer()
+      ..write(_WEEKDAYS[date.weekday - 1])
+      ..write(", ")
+      ..write(date.day <= 9 ? "0" : "")
+      ..write(date.day.toString())
+      ..write(" ")
+      ..write(_MONTHS[date.month - 1])
+      ..write(" ")
+      ..write(date.year.toString())
+      ..write(date.hour <= 9 ? " 0" : " ")
+      ..write(date.hour.toString())
+      ..write(date.minute <= 9 ? ":0" : ":")
+      ..write(date.minute.toString())
+      ..write(date.second <= 9 ? ":0" : ":")
+      ..write(date.second.toString())
+      ..write(" GMT");
+  return buffer.toString();
+}
+
+/// Parses an HTTP-formatted date into a UTC [DateTime].
+///
+/// This follows [RFC
+/// 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3). It will
+/// throw a [FormatException] if [date] is invalid.
+DateTime parseHttpDate(String date) {
+  try {
+    var scanner = new StringScanner(date);
+
+    if (scanner.scan(_longWeekdayRegExp)) {
+      // RFC 850 starts with a long weekday.
+      scanner.expect(", ");
+      var day = _parseInt(scanner, 2);
+      scanner.expect("-");
+      var month = _parseMonth(scanner);
+      scanner.expect("-");
+      var year = 1900 + _parseInt(scanner, 2);
+      scanner.expect(" ");
+      var time = _parseTime(scanner);
+      scanner.expect(" GMT");
+      scanner.expectDone();
+
+      return _makeDateTime(year, month, day, time);
+    }
+
+    // RFC 1123 and asctime both start with a short weekday.
+    scanner.expect(_shortWeekdayRegExp);
+    if (scanner.scan(", ")) {
+      // RFC 1123 follows the weekday with a comma.
+      var day = _parseInt(scanner, 2);
+      scanner.expect(" ");
+      var month = _parseMonth(scanner);
+      scanner.expect(" ");
+      var year = _parseInt(scanner, 4);
+      scanner.expect(" ");
+      var time = _parseTime(scanner);
+      scanner.expect(" GMT");
+      scanner.expectDone();
+
+      return _makeDateTime(year, month, day, time);
+    }
+
+    // asctime follows the weekday with a space.
+    scanner.expect(" ");
+    var month = _parseMonth(scanner);
+    scanner.expect(" ");
+    var day = scanner.scan(" ") ?
+        _parseInt(scanner, 1) :
+        _parseInt(scanner, 2);
+    scanner.expect(" ");
+    var time = _parseTime(scanner);
+    scanner.expect(" ");
+    var year = _parseInt(scanner, 4);
+    scanner.expectDone();
+
+    return _makeDateTime(year, month, day, time);
+  } on FormatException catch (error) {
+    throw new FormatException('Invalid HTTP date "$date": ${error.message}');
+  }
+}
+
+/// Parses a short-form month name to a form accepted by [DateTime].
+int _parseMonth(StringScanner scanner) {
+  scanner.expect(_monthRegExp);
+  // DateTime uses 1-indexed months.
+  return _MONTHS.indexOf(scanner.lastMatch[0]) + 1;
+}
+
+/// Parses an int an enforces that it has exactly [digits] digits.
+int _parseInt(StringScanner scanner, int digits) {
+  scanner.expect(_digitRegExp);
+  if (scanner.lastMatch[0].length != digits) {
+    scanner.error("expected a $digits-digit number.");
+  }
+
+  return int.parse(scanner.lastMatch[0]);
+}
+
+/// Parses an timestamp of the form "HH:MM:SS" on a 24-hour clock.
+DateTime _parseTime(StringScanner scanner) {
+  var hours = _parseInt(scanner, 2);
+  if (hours >= 24) scanner.error("hours may not be greater than 24.");
+  scanner.expect(':');
+
+  var minutes = _parseInt(scanner, 2);
+  if (minutes >= 60) scanner.error("minutes may not be greater than 60.");
+  scanner.expect(':');
+
+  var seconds = _parseInt(scanner, 2);
+  if (seconds >= 60) scanner.error("seconds may not be greater than 60.");
+
+  return new DateTime(1, 1, 1, hours, minutes, seconds);
+}
+
+/// Returns a UTC [DateTime] from the given components.
+///
+/// Validates that [day] is a valid day for [month]. If it's not, throws a
+/// [FormatException].
+DateTime _makeDateTime(int year, int month, int day, DateTime time) {
+  var dateTime = new DateTime.utc(
+      year, month, day, time.hour, time.minute, time.second);
+
+  // If [day] was too large, it will cause [month] to overflow.
+  if (dateTime.month != month) {
+    throw new FormatException("invalid day '$day' for month '$month'.");
+  }
+  return dateTime;
+}
diff --git a/lib/src/media_type.dart b/lib/src/media_type.dart
new file mode 100644
index 0000000..7a1ff23
--- /dev/null
+++ b/lib/src/media_type.dart
@@ -0,0 +1,161 @@
+// Copyright (c) 2014, 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 http_parser.media_type;
+
+import 'package:collection/collection.dart';
+import 'package:string_scanner/string_scanner.dart';
+
+// All of the following regular expressions come from section 2.2 of the HTTP
+// spec: http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html
+final _lws = new RegExp(r"(?:\r\n)?[ \t]+");
+final _token = new RegExp(r'[^()<>@,;:"\\/[\]?={} \t\x00-\x1F\x7F]+');
+final _quotedString = new RegExp(r'"(?:[^"\x00-\x1F\x7F]|\\.)*"');
+final _quotedPair = new RegExp(r'\\(.)');
+
+/// A regular expression matching any number of [_lws] productions in a row.
+final _whitespace = new RegExp("(?:${_lws.pattern})*");
+
+/// A regular expression matching a character that is not a valid HTTP token.
+final _nonToken = new RegExp(r'[()<>@,;:"\\/\[\]?={} \t\x00-\x1F\x7F]');
+
+/// A regular expression matching a character that needs to be backslash-escaped
+/// in a quoted string.
+final _escapedChar = new RegExp(r'["\x00-\x1F\x7F]');
+
+/// A class representing an HTTP media type, as used in Accept and Content-Type
+/// headers.
+///
+/// This is immutable; new instances can be created based on an old instance by
+/// calling [change].
+class MediaType {
+  /// The primary identifier of the MIME type.
+  final String type;
+
+  /// The secondary identifier of the MIME type.
+  final String subtype;
+
+  /// The parameters to the media type.
+  ///
+  /// This map is immutable.
+  final Map<String, String> parameters;
+
+  /// The media type's MIME type.
+  String get mimeType => "$type/$subtype";
+
+  /// Parses a media type.
+  ///
+  /// This will throw a FormatError if the media type is invalid.
+  factory MediaType.parse(String mediaType) {
+    // This parsing is based on sections 3.6 and 3.7 of the HTTP spec:
+    // http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html.
+    try {
+      var scanner = new StringScanner(mediaType);
+      scanner.scan(_whitespace);
+      scanner.expect(_token);
+      var type = scanner.lastMatch[0];
+      scanner.expect('/');
+      scanner.expect(_token);
+      var subtype = scanner.lastMatch[0];
+      scanner.scan(_whitespace);
+
+      var parameters = {};
+      while (scanner.scan(';')) {
+        scanner.scan(_whitespace);
+        scanner.expect(_token);
+        var attribute = scanner.lastMatch[0];
+        scanner.expect('=');
+
+        var value;
+        if (scanner.scan(_token)) {
+          value = scanner.lastMatch[0];
+        } else {
+          scanner.expect(_quotedString);
+          var quotedString = scanner.lastMatch[0];
+          value = quotedString.substring(1, quotedString.length - 1).
+              replaceAllMapped(_quotedPair, (match) => match[1]);
+        }
+
+        scanner.scan(_whitespace);
+        parameters[attribute] = value;
+      }
+
+      scanner.expectDone();
+      return new MediaType(type, subtype, parameters);
+    } on FormatException catch (error) {
+      throw new FormatException(
+          'Invalid media type "$mediaType": ${error.message}');
+    }
+  }
+
+  MediaType(this.type, this.subtype, [Map<String, String> parameters])
+      : this.parameters = new UnmodifiableMapView(
+          parameters == null ? {} : new Map.from(parameters));
+
+  /// Returns a copy of this [MediaType] with some fields altered.
+  ///
+  /// [type] and [subtype] alter the corresponding fields. [mimeType] is parsed
+  /// and alters both the [type] and [subtype] fields; it cannot be passed along
+  /// with [type] or [subtype].
+  ///
+  /// [parameters] overwrites and adds to the corresponding field. If
+  /// [clearParameters] is passed, it replaces the corresponding field entirely
+  /// instead.
+  MediaType change({String type, String subtype, String mimeType,
+      Map<String, String> parameters, bool clearParameters: false}) {
+    if (mimeType != null) {
+      if (type != null) {
+        throw new ArgumentError("You may not pass both [type] and [mimeType].");
+      } else if (subtype != null) {
+        throw new ArgumentError("You may not pass both [subtype] and "
+            "[mimeType].");
+      }
+
+      var segments = mimeType.split('/');
+      if (segments.length != 2) {
+        throw new FormatException('Invalid mime type "$mimeType".');
+      }
+
+      type = segments[0];
+      subtype = segments[1];
+    }
+
+    if (type == null) type = this.type;
+    if (subtype == null) subtype = this.subtype;
+    if (parameters == null) parameters = {};
+
+    if (!clearParameters) {
+      var newParameters = parameters;
+      parameters = new Map.from(this.parameters);
+      parameters.addAll(newParameters);
+    }
+
+    return new MediaType(type, subtype, parameters);
+  }
+
+  /// Converts the media type to a string.
+  ///
+  /// This will produce a valid HTTP media type.
+  String toString() {
+    var buffer = new StringBuffer()
+        ..write(type)
+        ..write("/")
+        ..write(subtype);
+
+    parameters.forEach((attribute, value) {
+      buffer.write("; $attribute=");
+      if (_nonToken.hasMatch(value)) {
+        buffer
+          ..write('"')
+          ..write(value.replaceAllMapped(
+              _escapedChar, (match) => "\\" + match[0]))
+          ..write('"');
+      } else {
+        buffer.write(value);
+      }
+    });
+
+    return buffer.toString();
+  }
+}
diff --git a/lib/src/web_socket.dart b/lib/src/web_socket.dart
new file mode 100644
index 0000000..77c9d2b
--- /dev/null
+++ b/lib/src/web_socket.dart
@@ -0,0 +1,936 @@
+// Copyright (c) 2014, 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 http_parser.web_socket;
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:math';
+import 'dart:typed_data';
+
+import 'package:crypto/crypto.dart';
+
+import 'bytes_builder.dart';
+
+/// An implementation of the WebSocket protocol that's not specific to "dart:io"
+/// or to any particular HTTP API.
+///
+/// Because this is HTTP-API-agnostic, it doesn't handle the initial [WebSocket
+/// handshake][]. This needs to be handled manually by the user of the code.
+/// Once that's been done, [new CompatibleWebSocket] can be called with the
+/// underlying socket and it will handle the remainder of the protocol.
+///
+/// [WebSocket handshake]: https://tools.ietf.org/html/rfc6455#section-4
+abstract class CompatibleWebSocket implements Stream, StreamSink {
+  /// The interval for sending ping signals.
+  ///
+  /// If a ping message is not answered by a pong message from the peer, the
+  /// `WebSocket` is assumed disconnected and the connection is closed with a
+  /// [WebSocketStatus.GOING_AWAY] close code. When a ping signal is sent, the
+  /// pong message must be received within [pingInterval].
+  ///
+  /// There are never two outstanding pings at any given time, and the next ping
+  /// timer starts when the pong is received.
+  ///
+  /// By default, the [pingInterval] is `null`, indicating that ping messages
+  /// are disabled.
+  Duration pingInterval;
+
+  /// The [close code][] set when the WebSocket connection is closed.
+  ///
+  /// [close code]: https://tools.ietf.org/html/rfc6455#section-7.1.5
+  ///
+  /// Before the connection has been closed, this will be `null`.
+  int get closeCode;
+
+  /// The [close reason][] set when the WebSocket connection is closed.
+  ///
+  /// [close reason]: https://tools.ietf.org/html/rfc6455#section-7.1.6
+  ///
+  /// Before the connection has been closed, this will be `null`.
+  String get closeReason;
+
+  /// Signs a `Sec-WebSocket-Key` header sent by a WebSocket client as part of
+  /// the [initial handshake].
+  ///
+  /// The return value should be sent back to the client in a
+  /// `Sec-WebSocket-Accept` header.
+  ///
+  /// [initial handshake]: https://tools.ietf.org/html/rfc6455#section-4.2.2
+  static String signKey(String key) {
+    var hash = new SHA1();
+    // We use [codeUnits] here rather than UTF-8-decoding the string because
+    // [key] is expected to be base64 encoded, and so will be pure ASCII.
+    hash.add((key + _webSocketGUID).codeUnits);
+    return CryptoUtils.bytesToBase64(hash.close());
+  }
+
+  /// Creates a new WebSocket handling messaging across an existing socket.
+  ///
+  /// Because this is HTTP-API-agnostic, the initial [WebSocket handshake][]
+  /// must have already been completed on the socket before this is called.
+  ///
+  /// If [stream] is also a [StreamSink] (for example, if it's a "dart:io"
+  /// `Socket`), it will be used for both sending and receiving data. Otherwise,
+  /// it will be used for receiving data and [sink] will be used for sending it.
+  ///
+  /// If this is a WebSocket server, [serverSide] should be `true` (the
+  /// default); if it's a client, [serverSide] should be `false`.
+  ///
+  /// [WebSocket handshake]: https://tools.ietf.org/html/rfc6455#section-4
+  factory CompatibleWebSocket(Stream<List<int>> stream,
+        {StreamSink<List<int>> sink, bool serverSide: true}) {
+    if (sink == null) {
+      if (stream is! StreamSink) {
+        throw new ArgumentError("If stream isn't also a StreamSink, sink must "
+            "be passed explicitly.");
+      }
+      sink = stream as StreamSink;
+    }
+
+    return new _WebSocketImpl._fromSocket(stream, sink, serverSide);
+  }
+
+  /// Closes the web socket connection.
+  ///
+  /// [closeCode] and [closeReason] are the [close code][] and [reason][] sent
+  /// to the remote peer, respectively. If they are omitted, the peer will see
+  /// a "no status received" code with no reason.
+  ///
+  /// [close code]: https://tools.ietf.org/html/rfc6455#section-7.1.5
+  /// [reason]: https://tools.ietf.org/html/rfc6455#section-7.1.6
+  Future close([int closeCode, String closeReason]);
+}
+
+/// An exception thrown by [CompatibleWebSocket].
+class CompatibleWebSocketException implements Exception {
+  final String message;
+
+  CompatibleWebSocketException([this.message]);
+
+  String toString() => message == null
+      ? "CompatibleWebSocketException" :
+        "CompatibleWebSocketException: $message";
+}
+
+// The following code is copied from sdk/lib/io/websocket_impl.dart. The
+// "dart:io" implementation isn't used directly both to support non-"dart:io"
+// applications, and because it's incompatible with non-"dart:io" HTTP requests
+// (issue 18172).
+//
+// Because it's copied directly, only modifications necessary to support the
+// desired public API and to remove "dart:io" dependencies have been made.
+
+/**
+ * Web socket status codes used when closing a web socket connection.
+ */
+abstract class _WebSocketStatus {
+  static const int NORMAL_CLOSURE = 1000;
+  static const int GOING_AWAY = 1001;
+  static const int PROTOCOL_ERROR = 1002;
+  static const int UNSUPPORTED_DATA = 1003;
+  static const int RESERVED_1004  = 1004;
+  static const int NO_STATUS_RECEIVED = 1005;
+  static const int ABNORMAL_CLOSURE = 1006;
+  static const int INVALID_FRAME_PAYLOAD_DATA = 1007;
+  static const int POLICY_VIOLATION = 1008;
+  static const int MESSAGE_TOO_BIG = 1009;
+  static const int MISSING_MANDATORY_EXTENSION = 1010;
+  static const int INTERNAL_SERVER_ERROR = 1011;
+  static const int RESERVED_1015 = 1015;
+}
+
+abstract class _WebSocketState {
+  static const int CONNECTING = 0;
+  static const int OPEN = 1;
+  static const int CLOSING = 2;
+  static const int CLOSED = 3;
+}
+
+const String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+final _random = new Random();
+
+// Matches _WebSocketOpcode.
+class _WebSocketMessageType {
+  static const int NONE = 0;
+  static const int TEXT = 1;
+  static const int BINARY = 2;
+}
+
+
+class _WebSocketOpcode {
+  static const int CONTINUATION = 0;
+  static const int TEXT = 1;
+  static const int BINARY = 2;
+  static const int RESERVED_3 = 3;
+  static const int RESERVED_4 = 4;
+  static const int RESERVED_5 = 5;
+  static const int RESERVED_6 = 6;
+  static const int RESERVED_7 = 7;
+  static const int CLOSE = 8;
+  static const int PING = 9;
+  static const int PONG = 10;
+  static const int RESERVED_B = 11;
+  static const int RESERVED_C = 12;
+  static const int RESERVED_D = 13;
+  static const int RESERVED_E = 14;
+  static const int RESERVED_F = 15;
+}
+
+/**
+ * The web socket protocol transformer handles the protocol byte stream
+ * which is supplied through the [:handleData:]. As the protocol is processed,
+ * it'll output frame data as either a List<int> or String.
+ *
+ * Important infomation about usage: Be sure you use cancelOnError, so the
+ * socket will be closed when the processer encounter an error. Not using it
+ * will lead to undefined behaviour.
+ */
+// TODO(ajohnsen): make this transformer reusable?
+class _WebSocketProtocolTransformer implements StreamTransformer, EventSink {
+  static const int START = 0;
+  static const int LEN_FIRST = 1;
+  static const int LEN_REST = 2;
+  static const int MASK = 3;
+  static const int PAYLOAD = 4;
+  static const int CLOSED = 5;
+  static const int FAILURE = 6;
+
+  int _state = START;
+  bool _fin = false;
+  int _opcode = -1;
+  int _len = -1;
+  bool _masked = false;
+  int _remainingLenBytes = -1;
+  int _remainingMaskingKeyBytes = 4;
+  int _remainingPayloadBytes = -1;
+  int _unmaskingIndex = 0;
+  int _currentMessageType = _WebSocketMessageType.NONE;
+  int closeCode = _WebSocketStatus.NO_STATUS_RECEIVED;
+  String closeReason = "";
+
+  EventSink _eventSink;
+
+  final bool _serverSide;
+  final List _maskingBytes = new List(4);
+  final BytesBuilder _payload = new BytesBuilder(copy: false);
+
+  _WebSocketProtocolTransformer([this._serverSide = false]);
+
+  Stream bind(Stream stream) {
+    return new Stream.eventTransformed(
+        stream,
+        (EventSink eventSink) {
+          if (_eventSink != null) {
+            throw new StateError("WebSocket transformer already used.");
+          }
+          _eventSink = eventSink;
+          return this;
+        });
+  }
+
+  void addError(Object error, [StackTrace stackTrace]) =>
+      _eventSink.addError(error, stackTrace);
+
+  void close() => _eventSink.close();
+
+  /**
+   * Process data received from the underlying communication channel.
+   */
+  void add(Uint8List buffer) {
+    int count = buffer.length;
+    int index = 0;
+    int lastIndex = count;
+    if (_state == CLOSED) {
+      throw new CompatibleWebSocketException("Data on closed connection");
+    }
+    if (_state == FAILURE) {
+      throw new CompatibleWebSocketException("Data on failed connection");
+    }
+    while ((index < lastIndex) && _state != CLOSED && _state != FAILURE) {
+      int byte = buffer[index];
+      if (_state <= LEN_REST) {
+        if (_state == START) {
+          _fin = (byte & 0x80) != 0;
+          if ((byte & 0x70) != 0) {
+            // The RSV1, RSV2 bits RSV3 must be all zero.
+            throw new CompatibleWebSocketException("Protocol error");
+          }
+          _opcode = (byte & 0xF);
+          if (_opcode <= _WebSocketOpcode.BINARY) {
+            if (_opcode == _WebSocketOpcode.CONTINUATION) {
+              if (_currentMessageType == _WebSocketMessageType.NONE) {
+                throw new CompatibleWebSocketException("Protocol error");
+              }
+            } else {
+              assert(_opcode == _WebSocketOpcode.TEXT ||
+                     _opcode == _WebSocketOpcode.BINARY);
+              if (_currentMessageType != _WebSocketMessageType.NONE) {
+                throw new CompatibleWebSocketException("Protocol error");
+              }
+              _currentMessageType = _opcode;
+            }
+          } else if (_opcode >= _WebSocketOpcode.CLOSE &&
+                     _opcode <= _WebSocketOpcode.PONG) {
+            // Control frames cannot be fragmented.
+            if (!_fin) throw new CompatibleWebSocketException("Protocol error");
+          } else {
+            throw new CompatibleWebSocketException("Protocol error");
+          }
+          _state = LEN_FIRST;
+        } else if (_state == LEN_FIRST) {
+          _masked = (byte & 0x80) != 0;
+          _len = byte & 0x7F;
+          if (_isControlFrame() && _len > 125) {
+            throw new CompatibleWebSocketException("Protocol error");
+          }
+          if (_len == 126) {
+            _len = 0;
+            _remainingLenBytes = 2;
+            _state = LEN_REST;
+          } else if (_len == 127) {
+            _len = 0;
+            _remainingLenBytes = 8;
+            _state = LEN_REST;
+          } else {
+            assert(_len < 126);
+            _lengthDone();
+          }
+        } else {
+          assert(_state == LEN_REST);
+          _len = _len << 8 | byte;
+          _remainingLenBytes--;
+          if (_remainingLenBytes == 0) {
+            _lengthDone();
+          }
+        }
+      } else {
+        if (_state == MASK) {
+          _maskingBytes[4 - _remainingMaskingKeyBytes--] = byte;
+          if (_remainingMaskingKeyBytes == 0) {
+            _maskDone();
+          }
+        } else {
+          assert(_state == PAYLOAD);
+          // The payload is not handled one byte at a time but in blocks.
+          int payloadLength = min(lastIndex - index, _remainingPayloadBytes);
+          _remainingPayloadBytes -= payloadLength;
+          // Unmask payload if masked.
+          if (_masked) {
+            _unmask(index, payloadLength, buffer);
+          }
+          // Control frame and data frame share _payloads.
+          _payload.add(
+              new Uint8List.view(buffer.buffer, index, payloadLength));
+          index += payloadLength;
+          if (_isControlFrame()) {
+            if (_remainingPayloadBytes == 0) _controlFrameEnd();
+          } else {
+            if (_currentMessageType != _WebSocketMessageType.TEXT &&
+                _currentMessageType != _WebSocketMessageType.BINARY) {
+                throw new CompatibleWebSocketException("Protocol error");
+            }
+            if (_remainingPayloadBytes == 0) _messageFrameEnd();
+          }
+
+          // Hack - as we always do index++ below.
+          index--;
+        }
+      }
+
+      // Move to the next byte.
+      index++;
+    }
+  }
+
+  void _unmask(int index, int length, Uint8List buffer) {
+    const int BLOCK_SIZE = 16;
+    // Skip Int32x4-version if message is small.
+    if (length >= BLOCK_SIZE) {
+      // Start by aligning to 16 bytes.
+      final int startOffset = BLOCK_SIZE - (index & 15);
+      final int end = index + startOffset;
+      for (int i = index; i < end; i++) {
+        buffer[i] ^= _maskingBytes[_unmaskingIndex++ & 3];
+      }
+      index += startOffset;
+      length -= startOffset;
+      final int blockCount = length ~/ BLOCK_SIZE;
+      if (blockCount > 0) {
+        // Create mask block.
+        int mask = 0;
+        for (int i = 3; i >= 0; i--) {
+          mask = (mask << 8) | _maskingBytes[(_unmaskingIndex + i) & 3];
+        }
+        Int32x4 blockMask = new Int32x4(mask, mask, mask, mask);
+        Int32x4List blockBuffer = new Int32x4List.view(
+            buffer.buffer, index, blockCount);
+        for (int i = 0; i < blockBuffer.length; i++) {
+          blockBuffer[i] ^= blockMask;
+        }
+        final int bytes = blockCount * BLOCK_SIZE;
+        index += bytes;
+        length -= bytes;
+      }
+    }
+    // Handle end.
+    final int end = index + length;
+    for (int i = index; i < end; i++) {
+      buffer[i] ^= _maskingBytes[_unmaskingIndex++ & 3];
+    }
+  }
+
+  void _lengthDone() {
+    if (_masked) {
+      if (!_serverSide) {
+        throw new CompatibleWebSocketException(
+            "Received masked frame from server");
+      }
+      _state = MASK;
+    } else {
+      if (_serverSide) {
+        throw new CompatibleWebSocketException(
+            "Received unmasked frame from client");
+      }
+      _remainingPayloadBytes = _len;
+      _startPayload();
+    }
+  }
+
+  void _maskDone() {
+    _remainingPayloadBytes = _len;
+    _startPayload();
+  }
+
+  void _startPayload() {
+    // If there is no actual payload perform perform callbacks without
+    // going through the PAYLOAD state.
+    if (_remainingPayloadBytes == 0) {
+      if (_isControlFrame()) {
+        switch (_opcode) {
+          case _WebSocketOpcode.CLOSE:
+            _state = CLOSED;
+            _eventSink.close();
+            break;
+          case _WebSocketOpcode.PING:
+            _eventSink.add(new _WebSocketPing());
+            break;
+          case _WebSocketOpcode.PONG:
+            _eventSink.add(new _WebSocketPong());
+            break;
+        }
+        _prepareForNextFrame();
+      } else {
+        _messageFrameEnd();
+      }
+    } else {
+      _state = PAYLOAD;
+    }
+  }
+
+  void _messageFrameEnd() {
+    if (_fin) {
+      switch (_currentMessageType) {
+        case _WebSocketMessageType.TEXT:
+          _eventSink.add(UTF8.decode(_payload.takeBytes()));
+          break;
+        case _WebSocketMessageType.BINARY:
+          _eventSink.add(_payload.takeBytes());
+          break;
+      }
+      _currentMessageType = _WebSocketMessageType.NONE;
+    }
+    _prepareForNextFrame();
+  }
+
+  void _controlFrameEnd() {
+    switch (_opcode) {
+      case _WebSocketOpcode.CLOSE:
+        closeCode = _WebSocketStatus.NO_STATUS_RECEIVED;
+        var payload = _payload.takeBytes();
+        if (payload.length > 0) {
+          if (payload.length == 1) {
+            throw new CompatibleWebSocketException("Protocol error");
+          }
+          closeCode = payload[0] << 8 | payload[1];
+          if (closeCode == _WebSocketStatus.NO_STATUS_RECEIVED) {
+            throw new CompatibleWebSocketException("Protocol error");
+          }
+          if (payload.length > 2) {
+            closeReason = UTF8.decode(payload.sublist(2));
+          }
+        }
+        _state = CLOSED;
+        _eventSink.close();
+        break;
+
+      case _WebSocketOpcode.PING:
+        _eventSink.add(new _WebSocketPing(_payload.takeBytes()));
+        break;
+
+      case _WebSocketOpcode.PONG:
+        _eventSink.add(new _WebSocketPong(_payload.takeBytes()));
+        break;
+    }
+    _prepareForNextFrame();
+  }
+
+  bool _isControlFrame() {
+    return _opcode == _WebSocketOpcode.CLOSE ||
+           _opcode == _WebSocketOpcode.PING ||
+           _opcode == _WebSocketOpcode.PONG;
+  }
+
+  void _prepareForNextFrame() {
+    if (_state != CLOSED && _state != FAILURE) _state = START;
+    _fin = false;
+    _opcode = -1;
+    _len = -1;
+    _remainingLenBytes = -1;
+    _remainingMaskingKeyBytes = 4;
+    _remainingPayloadBytes = -1;
+    _unmaskingIndex = 0;
+  }
+}
+
+
+class _WebSocketPing {
+  final List<int> payload;
+  _WebSocketPing([this.payload = null]);
+}
+
+
+class _WebSocketPong {
+  final List<int> payload;
+  _WebSocketPong([this.payload = null]);
+}
+
+// TODO(ajohnsen): Make this transformer reusable.
+class _WebSocketOutgoingTransformer implements StreamTransformer, EventSink {
+  final _WebSocketImpl webSocket;
+  EventSink _eventSink;
+
+  _WebSocketOutgoingTransformer(this.webSocket);
+
+  Stream bind(Stream stream) {
+    return new Stream.eventTransformed(
+        stream,
+        (EventSink eventSink) {
+          if (_eventSink != null) {
+            throw new StateError("WebSocket transformer already used");
+          }
+          _eventSink = eventSink;
+          return this;
+        });
+  }
+
+  void add(message) {
+    if (message is _WebSocketPong) {
+      addFrame(_WebSocketOpcode.PONG, message.payload);
+      return;
+    }
+    if (message is _WebSocketPing) {
+      addFrame(_WebSocketOpcode.PING, message.payload);
+      return;
+    }
+    List<int> data;
+    int opcode;
+    if (message != null) {
+      if (message is String) {
+        opcode = _WebSocketOpcode.TEXT;
+        data = UTF8.encode(message);
+      } else {
+        if (message is !List<int>) {
+          throw new ArgumentError(message);
+        }
+        opcode = _WebSocketOpcode.BINARY;
+        data = message;
+      }
+    } else {
+      opcode = _WebSocketOpcode.TEXT;
+    }
+    addFrame(opcode, data);
+  }
+
+  void addError(Object error, [StackTrace stackTrace]) =>
+      _eventSink.addError(error, stackTrace);
+
+  void close() {
+    int code = webSocket._outCloseCode;
+    String reason = webSocket._outCloseReason;
+    List<int> data;
+    if (code != null) {
+      data = new List<int>();
+      data.add((code >> 8) & 0xFF);
+      data.add(code & 0xFF);
+      if (reason != null) {
+        data.addAll(UTF8.encode(reason));
+      }
+    }
+    addFrame(_WebSocketOpcode.CLOSE, data);
+    _eventSink.close();
+  }
+
+  void addFrame(int opcode, List<int> data) =>
+      createFrame(opcode, data, webSocket._serverSide).forEach(_eventSink.add);
+
+  static Iterable createFrame(int opcode, List<int> data, bool serverSide) {
+    bool mask = !serverSide;  // Masking not implemented for server.
+    int dataLength = data == null ? 0 : data.length;
+    // Determine the header size.
+    int headerSize = (mask) ? 6 : 2;
+    if (dataLength > 65535) {
+      headerSize += 8;
+    } else if (dataLength > 125) {
+      headerSize += 2;
+    }
+    Uint8List header = new Uint8List(headerSize);
+    int index = 0;
+    // Set FIN and opcode.
+    header[index++] = 0x80 | opcode;
+    // Determine size and position of length field.
+    int lengthBytes = 1;
+    int firstLengthByte = 1;
+    if (dataLength > 65535) {
+      header[index++] = 127;
+      lengthBytes = 8;
+    } else if (dataLength > 125) {
+      header[index++] = 126;
+      lengthBytes = 2;
+    }
+    // Write the length in network byte order into the header.
+    for (int i = 0; i < lengthBytes; i++) {
+      header[index++] = dataLength >> (((lengthBytes - 1) - i) * 8) & 0xFF;
+    }
+    if (mask) {
+      header[1] |= 1 << 7;
+      var maskBytes = [_random.nextInt(256), _random.nextInt(256),
+          _random.nextInt(256), _random.nextInt(256)];
+      header.setRange(index, index + 4, maskBytes);
+      index += 4;
+      if (data != null) {
+        Uint8List list;
+        // If this is a text message just do the masking inside the
+        // encoded data.
+        if (opcode == _WebSocketOpcode.TEXT && data is Uint8List) {
+          list = data;
+        } else {
+          if (data is Uint8List) {
+            list = new Uint8List.fromList(data);
+          } else {
+            list = new Uint8List(data.length);
+            for (int i = 0; i < data.length; i++) {
+              if (data[i] < 0 || 255 < data[i]) {
+                throw new ArgumentError(
+                    "List element is not a byte value "
+                    "(value ${data[i]} at index $i)");
+              }
+              list[i] = data[i];
+            }
+          }
+        }
+        const int BLOCK_SIZE = 16;
+        int blockCount = list.length ~/ BLOCK_SIZE;
+        if (blockCount > 0) {
+          // Create mask block.
+          int mask = 0;
+          for (int i = 3; i >= 0; i--) {
+            mask = (mask << 8) | maskBytes[i];
+          }
+          Int32x4 blockMask = new Int32x4(mask, mask, mask, mask);
+          Int32x4List blockBuffer = new Int32x4List.view(
+              list.buffer, 0, blockCount);
+          for (int i = 0; i < blockBuffer.length; i++) {
+            blockBuffer[i] ^= blockMask;
+          }
+        }
+        // Handle end.
+        for (int i = blockCount * BLOCK_SIZE; i < list.length; i++) {
+          list[i] ^= maskBytes[i & 3];
+        }
+        data = list;
+      }
+    }
+    assert(index == headerSize);
+    if (data == null) {
+      return [header];
+    } else {
+      return [header, data];
+    }
+  }
+}
+
+
+class _WebSocketConsumer implements StreamConsumer {
+  final _WebSocketImpl webSocket;
+  final StreamSink<List<int>> sink;
+  StreamController _controller;
+  StreamSubscription _subscription;
+  bool _issuedPause = false;
+  bool _closed = false;
+  Completer _closeCompleter = new Completer();
+  Completer _completer;
+
+  _WebSocketConsumer(this.webSocket, this.sink);
+
+  void _onListen() {
+    if (_subscription != null) {
+      _subscription.cancel();
+    }
+  }
+
+  void _onPause() {
+    if (_subscription != null) {
+      _subscription.pause();
+    } else {
+      _issuedPause = true;
+    }
+  }
+
+  void _onResume() {
+    if (_subscription != null) {
+      _subscription.resume();
+    } else {
+      _issuedPause = false;
+    }
+  }
+
+  void _cancel() {
+    if (_subscription != null) {
+      var subscription = _subscription;
+      _subscription = null;
+      subscription.cancel();
+    }
+  }
+
+  _ensureController() {
+    if (_controller != null) return;
+    _controller = new StreamController(sync: true,
+                                       onPause: _onPause,
+                                       onResume: _onResume,
+                                       onCancel: _onListen);
+    var stream = _controller.stream.transform(
+        new _WebSocketOutgoingTransformer(webSocket));
+    sink.addStream(stream)
+        .then((_) {
+          _done();
+          _closeCompleter.complete(webSocket);
+        }, onError: (error, StackTrace stackTrace) {
+          _closed = true;
+          _cancel();
+          if (error is ArgumentError) {
+            if (!_done(error, stackTrace)) {
+              _closeCompleter.completeError(error, stackTrace);
+            }
+          } else {
+            _done();
+            _closeCompleter.complete(webSocket);
+          }
+        });
+  }
+
+  bool _done([error, StackTrace stackTrace]) {
+    if (_completer == null) return false;
+    if (error != null) {
+      _completer.completeError(error, stackTrace);
+    } else {
+      _completer.complete(webSocket);
+    }
+    _completer = null;
+    return true;
+  }
+
+  Future addStream(var stream) {
+    if (_closed) {
+      stream.listen(null).cancel();
+      return new Future.value(webSocket);
+    }
+    _ensureController();
+    _completer = new Completer();
+    _subscription = stream.listen(
+        (data) {
+          _controller.add(data);
+        },
+        onDone: _done,
+        onError: _done,
+        cancelOnError: true);
+    if (_issuedPause) {
+      _subscription.pause();
+      _issuedPause = false;
+    }
+    return _completer.future;
+  }
+
+  Future close() {
+    _ensureController();
+    Future closeSocket() {
+      return sink.close().catchError((_) {}).then((_) => webSocket);
+    }
+    _controller.close();
+    return _closeCompleter.future.then((_) => closeSocket());
+  }
+
+  void add(data) {
+    if (_closed) return;
+    _ensureController();
+    _controller.add(data);
+  }
+
+  void closeSocket() {
+    _closed = true;
+    _cancel();
+    close();
+  }
+}
+
+
+class _WebSocketImpl extends Stream implements CompatibleWebSocket {
+  StreamController _controller;
+  StreamSubscription _subscription;
+  StreamController _sink;
+
+  final bool _serverSide;
+  int _readyState = _WebSocketState.CONNECTING;
+  bool _writeClosed = false;
+  int _closeCode;
+  String _closeReason;
+  Duration _pingInterval;
+  Timer _pingTimer;
+  _WebSocketConsumer _consumer;
+
+  int _outCloseCode;
+  String _outCloseReason;
+  Timer _closeTimer;
+
+  _WebSocketImpl._fromSocket(Stream<List<int>> stream,
+      StreamSink<List<int>> sink, [this._serverSide = false]) {
+    _consumer = new _WebSocketConsumer(this, sink);
+    _sink = new StreamController();
+    _sink.stream.pipe(_consumer);
+    _readyState = _WebSocketState.OPEN;
+
+    var transformer = new _WebSocketProtocolTransformer(_serverSide);
+    _subscription = stream.transform(transformer).listen(
+        (data) {
+          if (data is _WebSocketPing) {
+            if (!_writeClosed) _consumer.add(new _WebSocketPong(data.payload));
+          } else if (data is _WebSocketPong) {
+            // Simply set pingInterval, as it'll cancel any timers.
+            pingInterval = _pingInterval;
+          } else {
+            _controller.add(data);
+          }
+        },
+        onError: (error) {
+          if (_closeTimer != null) _closeTimer.cancel();
+          if (error is FormatException) {
+            _close(_WebSocketStatus.INVALID_FRAME_PAYLOAD_DATA);
+          } else {
+            _close(_WebSocketStatus.PROTOCOL_ERROR);
+          }
+          _controller.close();
+        },
+        onDone: () {
+          if (_closeTimer != null) _closeTimer.cancel();
+          if (_readyState == _WebSocketState.OPEN) {
+            _readyState = _WebSocketState.CLOSING;
+            if (!_isReservedStatusCode(transformer.closeCode)) {
+              _close(transformer.closeCode);
+            } else {
+              _close();
+            }
+            _readyState = _WebSocketState.CLOSED;
+          }
+          _closeCode = transformer.closeCode;
+          _closeReason = transformer.closeReason;
+          _controller.close();
+        },
+        cancelOnError: true);
+    _subscription.pause();
+    _controller = new StreamController(sync: true,
+                                       onListen: _subscription.resume,
+                                       onPause: _subscription.pause,
+                                       onResume: _subscription.resume);
+  }
+
+  StreamSubscription listen(void onData(message),
+                            {Function onError,
+                             void onDone(),
+                             bool cancelOnError}) {
+    return _controller.stream.listen(onData,
+                                     onError: onError,
+                                     onDone: onDone,
+                                     cancelOnError: cancelOnError);
+  }
+
+  Duration get pingInterval => _pingInterval;
+
+  void set pingInterval(Duration interval) {
+    if (_writeClosed) return;
+    if (_pingTimer != null) _pingTimer.cancel();
+    _pingInterval = interval;
+
+    if (_pingInterval == null) return;
+
+    _pingTimer = new Timer(_pingInterval, () {
+      if (_writeClosed) return;
+      _consumer.add(new _WebSocketPing());
+      _pingTimer = new Timer(_pingInterval, () {
+        // No pong received.
+        _close(_WebSocketStatus.GOING_AWAY);
+      });
+    });
+  }
+
+  int get closeCode => _closeCode;
+  String get closeReason => _closeReason;
+
+  void add(data) => _sink.add(data);
+  void addError(error, [StackTrace stackTrace]) =>
+      _sink.addError(error, stackTrace);
+  Future addStream(Stream stream) => _sink.addStream(stream);
+  Future get done => _sink.done;
+
+  Future close([int code, String reason]) {
+    if (_isReservedStatusCode(code)) {
+      throw new CompatibleWebSocketException("Reserved status code $code");
+    }
+    if (_outCloseCode == null) {
+      _outCloseCode = code;
+      _outCloseReason = reason;
+    }
+    if (_closeTimer == null && !_controller.isClosed) {
+      // When closing the web-socket, we no longer accept data.
+      _closeTimer = new Timer(const Duration(seconds: 5), () {
+        _subscription.cancel();
+        _controller.close();
+      });
+    }
+    return _sink.close();
+  }
+
+  void _close([int code, String reason]) {
+    if (_writeClosed) return;
+    if (_outCloseCode == null) {
+      _outCloseCode = code;
+      _outCloseReason = reason;
+    }
+    _writeClosed = true;
+    _consumer.closeSocket();
+  }
+
+  static bool _isReservedStatusCode(int code) {
+    return code != null &&
+           (code < _WebSocketStatus.NORMAL_CLOSURE ||
+            code == _WebSocketStatus.RESERVED_1004 ||
+            code == _WebSocketStatus.NO_STATUS_RECEIVED ||
+            code == _WebSocketStatus.ABNORMAL_CLOSURE ||
+            (code > _WebSocketStatus.INTERNAL_SERVER_ERROR &&
+             code < _WebSocketStatus.RESERVED_1015) ||
+            (code >= _WebSocketStatus.RESERVED_1015 &&
+             code < 3000));
+  }
+}
+
diff --git a/pubspec.yaml b/pubspec.yaml
new file mode 100644
index 0000000..af1a192
--- /dev/null
+++ b/pubspec.yaml
@@ -0,0 +1,14 @@
+name: http_parser
+version: 0.0.2+3
+author: "Dart Team <misc@dartlang.org>"
+homepage: http://www.dartlang.org
+description: >
+  A platform-independent package for parsing and serializing HTTP formats.
+dependencies:
+  crypto: ">=0.9.0 <0.10.0"
+  collection: ">=0.9.1 <0.10.0"
+  string_scanner: ">=0.0.0 <0.1.0"
+dev_dependencies:
+  unittest: ">=0.10.0 <0.11.0"
+environment:
+  sdk: ">=1.2.0 <2.0.0"
diff --git a/test/http_date_test.dart b/test/http_date_test.dart
new file mode 100644
index 0000000..303d6d7
--- /dev/null
+++ b/test/http_date_test.dart
@@ -0,0 +1,347 @@
+// Copyright (c) 2014, 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 http_parser.http_date_test;
+
+import 'package:http_parser/http_parser.dart';
+import 'package:unittest/unittest.dart';
+
+void main() {
+  group('format', () {
+    test('many values with 9', () {
+      var date = new DateTime.utc(2014, 9, 9, 9, 9, 9);
+      var formatted = formatHttpDate(date);
+
+      expect(formatted, 'Tue, 09 Sep 2014 09:09:09 GMT');
+      var parsed = parseHttpDate(formatted);
+
+      expect(parsed, date);
+    });
+
+    test('end of year', () {
+      var date = new DateTime.utc(1999, 12, 31, 23, 59, 59);
+      var formatted = formatHttpDate(date);
+
+      expect(formatted, 'Fri, 31 Dec 1999 23:59:59 GMT');
+      var parsed = parseHttpDate(formatted);
+
+      expect(parsed, date);
+    });
+
+    test('start of year', () {
+      var date = new DateTime.utc(2000, 1, 1, 0, 0, 0);
+      var formatted = formatHttpDate(date);
+
+      expect(formatted, 'Sat, 01 Jan 2000 00:00:00 GMT');
+      var parsed = parseHttpDate(formatted);
+
+      expect(parsed, date);
+    });
+  });
+
+  group("parse", () {
+    group("RFC 1123", () {
+      test("parses the example date", () {
+        var date = parseHttpDate("Sun, 06 Nov 1994 08:49:37 GMT");
+        expect(date.day, equals(6));
+        expect(date.month, equals(DateTime.NOVEMBER));
+        expect(date.year, equals(1994));
+        expect(date.hour, equals(8));
+        expect(date.minute, equals(49));
+        expect(date.second, equals(37));
+        expect(date.timeZoneName, equals("UTC"));
+      });
+
+      test("whitespace is required", () {
+        expect(() => parseHttpDate("Sun,06 Nov 1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06Nov 1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 199408:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994 08:49:37GMT"),
+            throwsFormatException);
+      });
+
+      test("exactly one space is required", () {
+        expect(() => parseHttpDate("Sun,  06 Nov 1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06  Nov 1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov  1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994  08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994 08:49:37  GMT"),
+            throwsFormatException);
+      });
+
+      test("requires precise number lengths", () {
+        expect(() => parseHttpDate("Sun, 6 Nov 1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 94 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994 8:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994 08:9:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994 08:49:7 GMT"),
+            throwsFormatException);
+      });
+
+      test("requires reasonable numbers", () {
+        expect(() => parseHttpDate("Sun, 00 Nov 1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 31 Nov 1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 32 Aug 1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994 24:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994 08:60:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun, 06 Nov 1994 08:49:60 GMT"),
+            throwsFormatException);
+      });
+
+      test("only allows short weekday names", () {
+        expect(() => parseHttpDate("Sunday, 6 Nov 1994 08:49:37 GMT"),
+            throwsFormatException);
+      });
+
+      test("only allows short month names", () {
+        expect(() => parseHttpDate("Sun, 6 November 1994 08:49:37 GMT"),
+            throwsFormatException);
+      });
+
+      test("only allows GMT", () {
+        expect(() => parseHttpDate("Sun, 6 Nov 1994 08:49:37 PST"),
+            throwsFormatException);
+      });
+
+      test("disallows trailing whitespace", () {
+        expect(() => parseHttpDate("Sun, 6 Nov 1994 08:49:37 GMT "),
+            throwsFormatException);
+      });
+    });
+
+    group("RFC 850", () {
+      test("parses the example date", () {
+        var date = parseHttpDate("Sunday, 06-Nov-94 08:49:37 GMT");
+        expect(date.day, equals(6));
+        expect(date.month, equals(DateTime.NOVEMBER));
+        expect(date.year, equals(1994));
+        expect(date.hour, equals(8));
+        expect(date.minute, equals(49));
+        expect(date.second, equals(37));
+        expect(date.timeZoneName, equals("UTC"));
+      });
+
+      test("whitespace is required", () {
+        expect(() => parseHttpDate("Sunday,06-Nov-94 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-9408:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94 08:49:37GMT"),
+            throwsFormatException);
+      });
+
+      test("exactly one space is required", () {
+        expect(() => parseHttpDate("Sunday,  06-Nov-94 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94  08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94 08:49:37  GMT"),
+            throwsFormatException);
+      });
+
+      test("requires precise number lengths", () {
+        expect(() => parseHttpDate("Sunday, 6-Nov-94 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-1994 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94 8:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94 08:9:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94 08:49:7 GMT"),
+            throwsFormatException);
+      });
+
+      test("requires reasonable numbers", () {
+        expect(() => parseHttpDate("Sunday, 00-Nov-94 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 31-Nov-94 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 32-Aug-94 08:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94 24:49:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94 08:60:37 GMT"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sunday, 06-Nov-94 08:49:60 GMT"),
+            throwsFormatException);
+      });
+
+      test("only allows long weekday names", () {
+        expect(() => parseHttpDate("Sun, 6-Nov-94 08:49:37 GMT"),
+            throwsFormatException);
+      });
+
+      test("only allows short month names", () {
+        expect(() => parseHttpDate("Sunday, 6-November-94 08:49:37 GMT"),
+            throwsFormatException);
+      });
+
+      test("only allows GMT", () {
+        expect(() => parseHttpDate("Sunday, 6-Nov-94 08:49:37 PST"),
+            throwsFormatException);
+      });
+
+      test("disallows trailing whitespace", () {
+        expect(() => parseHttpDate("Sunday, 6-Nov-94 08:49:37 GMT "),
+            throwsFormatException);
+      });
+    });
+
+    group("asctime()", () {
+      test("parses the example date", () {
+        var date = parseHttpDate("Sun Nov  6 08:49:37 1994");
+        expect(date.day, equals(6));
+        expect(date.month, equals(DateTime.NOVEMBER));
+        expect(date.year, equals(1994));
+        expect(date.hour, equals(8));
+        expect(date.minute, equals(49));
+        expect(date.second, equals(37));
+        expect(date.timeZoneName, equals("UTC"));
+      });
+
+      test("parses a date with a two-digit day", () {
+        var date = parseHttpDate("Sun Nov 16 08:49:37 1994");
+        expect(date.day, equals(16));
+        expect(date.month, equals(DateTime.NOVEMBER));
+        expect(date.year, equals(1994));
+        expect(date.hour, equals(8));
+        expect(date.minute, equals(49));
+        expect(date.second, equals(37));
+        expect(date.timeZoneName, equals("UTC"));
+      });
+
+      test("whitespace is required", () {
+        expect(() => parseHttpDate("SunNov  6 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov6 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  608:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 08:49:371994"),
+            throwsFormatException);
+      });
+
+      test("the right amount of whitespace is required", () {
+        expect(() => parseHttpDate("Sun  Nov  6 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov   6 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov 6 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6  08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 08:49:37  1994"),
+            throwsFormatException);
+      });
+
+      test("requires precise number lengths", () {
+        expect(() => parseHttpDate("Sun Nov 016 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 8:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 08:9:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 08:49:7 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 08:49:37 94"),
+            throwsFormatException);
+      });
+
+      test("requires reasonable numbers", () {
+        expect(() => parseHttpDate("Sun Nov 0 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov 31 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Aug 32 08:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 24:49:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 08:60:37 1994"),
+            throwsFormatException);
+
+        expect(() => parseHttpDate("Sun Nov  6 08:49:60 1994"),
+            throwsFormatException);
+      });
+
+      test("only allows short weekday names", () {
+        expect(() => parseHttpDate("Sunday Nov 0 08:49:37 1994"),
+            throwsFormatException);
+      });
+
+      test("only allows short month names", () {
+        expect(() => parseHttpDate("Sun November 0 08:49:37 1994"),
+            throwsFormatException);
+      });
+
+      test("disallows trailing whitespace", () {
+        expect(() => parseHttpDate("Sun November 0 08:49:37 1994 "),
+            throwsFormatException);
+      });
+    });
+  });
+}
diff --git a/test/media_type_test.dart b/test/media_type_test.dart
new file mode 100644
index 0000000..14affbb
--- /dev/null
+++ b/test/media_type_test.dart
@@ -0,0 +1,163 @@
+// Copyright (c) 2014, 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 http_parser.media_type_test;
+
+import 'package:http_parser/http_parser.dart';
+import 'package:unittest/unittest.dart';
+
+void main() {
+  group("parse", () {
+    test("parses a simple MIME type", () {
+      var type = new MediaType.parse("text/plain");
+      expect(type.type, equals("text"));
+      expect(type.subtype, equals("plain"));
+    });
+
+    test("allows leading whitespace", () {
+      expect(new MediaType.parse(" text/plain").mimeType, equals("text/plain"));
+      expect(new MediaType.parse("\ttext/plain").mimeType,
+          equals("text/plain"));
+    });
+
+    test("allows trailing whitespace", () {
+      expect(new MediaType.parse("text/plain ").mimeType, equals("text/plain"));
+      expect(new MediaType.parse("text/plain\t").mimeType,
+          equals("text/plain"));
+    });
+
+    test("disallows separators in the MIME type", () {
+      expect(() => new MediaType.parse("te(xt/plain"), throwsFormatException);
+      expect(() => new MediaType.parse("text/pla=in"), throwsFormatException);
+    });
+
+    test("disallows whitespace around the slash", () {
+      expect(() => new MediaType.parse("text /plain"), throwsFormatException);
+      expect(() => new MediaType.parse("text/ plain"), throwsFormatException);
+    });
+
+    test("parses parameters", () {
+      var type = new MediaType.parse("text/plain;foo=bar;baz=bang");
+      expect(type.mimeType, equals("text/plain"));
+      expect(type.parameters, equals({"foo": "bar", "baz": "bang"}));
+    });
+
+    test("allows whitespace around the semicolon", () {
+      var type = new MediaType.parse("text/plain ; foo=bar ; baz=bang");
+      expect(type.mimeType, equals("text/plain"));
+      expect(type.parameters, equals({"foo": "bar", "baz": "bang"}));
+    });
+
+    test("disallows whitespace around the equals", () {
+      expect(() => new MediaType.parse("text/plain; foo =bar"),
+          throwsFormatException);
+      expect(() => new MediaType.parse("text/plain; foo= bar"),
+          throwsFormatException);
+    });
+
+    test("disallows separators in the parameters", () {
+      expect(() => new MediaType.parse("text/plain; fo:o=bar"),
+          throwsFormatException);
+      expect(() => new MediaType.parse("text/plain; foo=b@ar"),
+          throwsFormatException);
+    });
+
+    test("parses quoted parameters", () {
+      var type = new MediaType.parse(
+          'text/plain; foo="bar space"; baz="bang\\\\escape"');
+      expect(type.mimeType, equals("text/plain"));
+      expect(type.parameters, equals({
+        "foo": "bar space",
+        "baz": "bang\\escape"
+      }));
+    });
+  });
+
+  group("change", () {
+    var type;
+    setUp(() {
+      type = new MediaType.parse("text/plain; foo=bar; baz=bang");
+    });
+
+    test("uses the existing fields by default", () {
+      var newType = type.change();
+      expect(newType.type, equals("text"));
+      expect(newType.subtype, equals("plain"));
+      expect(newType.parameters, equals({"foo": "bar", "baz": "bang"}));
+    });
+
+    test("[type] overrides the existing type", () {
+      expect(type.change(type: "new").type, equals("new"));
+    });
+
+    test("[subtype] overrides the existing subtype", () {
+      expect(type.change(subtype: "new").subtype, equals("new"));
+    });
+
+    test("[mimeType] overrides the existing type and subtype", () {
+      var newType = type.change(mimeType: "image/png");
+      expect(newType.type, equals("image"));
+      expect(newType.subtype, equals("png"));
+    });
+
+    test("[parameters] overrides and adds to existing parameters", () {
+      expect(type.change(parameters: {
+        "foo": "zap",
+        "qux": "fblthp"
+      }).parameters, equals({
+        "foo": "zap",
+        "baz": "bang",
+        "qux": "fblthp"
+      }));
+    });
+
+    test("[clearParameters] removes existing parameters", () {
+      expect(type.change(clearParameters: true).parameters, isEmpty);
+    });
+
+    test("[clearParameters] with [parameters] removes before adding", () {
+      var newType = type.change(
+          parameters: {"foo": "zap"},
+          clearParameters: true);
+      expect(newType.parameters, equals({"foo": "zap"}));
+    });
+
+    test("[type] with [mimeType] is illegal", () {
+      expect(() => type.change(type: "new", mimeType: "image/png"),
+          throwsArgumentError);
+    });
+
+    test("[subtype] with [mimeType] is illegal", () {
+      expect(() => type.change(subtype: "new", mimeType: "image/png"),
+          throwsArgumentError);
+    });
+  });
+
+  group("toString", () {
+    test("serializes a simple MIME type", () {
+      expect(new MediaType("text", "plain").toString(), equals("text/plain"));
+    });
+
+    test("serializes a token parameter as a token", () {
+      expect(new MediaType("text", "plain", {"foo": "bar"}).toString(),
+          equals("text/plain; foo=bar"));
+    });
+
+    test("serializes a non-token parameter as a quoted string", () {
+      expect(new MediaType("text", "plain", {"foo": "bar baz"}).toString(),
+          equals('text/plain; foo="bar baz"'));
+    });
+
+    test("escapes a quoted string as necessary", () {
+      expect(new MediaType("text", "plain", {"foo": 'bar"\x7Fbaz'}).toString(),
+          equals('text/plain; foo="bar\\"\\\x7Fbaz"'));
+    });
+
+    test("serializes multiple parameters", () {
+      expect(new MediaType("text", "plain", {
+        "foo": "bar", "baz": "bang"
+      }).toString(), equals("text/plain; foo=bar; baz=bang"));
+    });
+  });
+}
diff --git a/test/web_socket_test.dart b/test/web_socket_test.dart
new file mode 100644
index 0000000..45b84d9
--- /dev/null
+++ b/test/web_socket_test.dart
@@ -0,0 +1,95 @@
+// Copyright (c) 2014, 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 http_parser.web_socket_test;
+
+import 'dart:io';
+
+import 'package:http_parser/http_parser.dart';
+import 'package:unittest/unittest.dart';
+
+void main() {
+  test("a client can communicate with a WebSocket server", () {
+    return HttpServer.bind("localhost", 0).then((server) {
+      server.transform(new WebSocketTransformer()).listen((webSocket) {
+        webSocket.add("hello!");
+        webSocket.first.then((request) {
+          expect(request, equals("ping"));
+          webSocket.add("pong");
+          webSocket.close();
+        });
+      });
+
+      var client = new HttpClient();
+      return client.openUrl("GET", Uri.parse("http://localhost:${server.port}"))
+          .then((request) {
+        request.headers
+            ..set("Connection", "Upgrade")
+            ..set("Upgrade", "websocket")
+            ..set("Sec-WebSocket-Key", "x3JJHMbDL1EzLkh9GBhXDw==")
+            ..set("Sec-WebSocket-Version", "13");
+        return request.close();
+      }).then((response) => response.detachSocket()).then((socket) {
+        var webSocket = new CompatibleWebSocket(socket, serverSide: false);
+
+        var n = 0;
+        return webSocket.listen((message) {
+          if (n == 0) {
+            expect(message, equals("hello!"));
+            webSocket.add("ping");
+          } else if (n == 1) {
+            expect(message, equals("pong"));
+            webSocket.close();
+            server.close();
+          } else {
+            fail("Only expected two messages.");
+          }
+          n++;
+        }).asFuture();
+      });
+    });
+  });
+
+  test("a server can communicate with a WebSocket client", () {
+    return HttpServer.bind("localhost", 0).then((server) {
+      server.listen((request) {
+        var response = request.response;
+        response.statusCode = 101;
+        response.headers
+            ..set("Connection", "Upgrade")
+            ..set("Upgrade", "websocket")
+            ..set("Sec-WebSocket-Accept", CompatibleWebSocket.signKey(
+                request.headers.value('Sec-WebSocket-Key')));
+        response.contentLength = 0;
+        response.detachSocket().then((socket) {
+          var webSocket = new CompatibleWebSocket(socket);
+          webSocket.add("hello!");
+          webSocket.first.then((request) {
+            expect(request, equals("ping"));
+            webSocket.add("pong");
+            webSocket.close();
+          });
+        });
+      });
+
+      return WebSocket.connect('ws://localhost:${server.port}')
+          .then((webSocket) {
+        var n = 0;
+        return webSocket.listen((message) {
+          if (n == 0) {
+            expect(message, equals("hello!"));
+            webSocket.add("ping");
+          } else if (n == 1) {
+            expect(message, equals("pong"));
+            webSocket.close();
+            server.close();
+          } else {
+            fail("Only expected two messages.");
+          }
+          n++;
+        }).asFuture();
+      });
+    });
+  });
+}