WebSocket Compression

sdk/lib/io/websocket.dart

 // 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.
 
 part of dart.io;
 
 /**
  * WebSocket status codes used when closing a WebSocket 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;
 }
 
 /**
+ * The [CompressionOptions] class allows you to control
+ * the options of WebSocket compression.
+ */
+class CompressionOptions {
+  /**
+   * Default WebSocket Compression options.
+   * Compression will be enabled with the following options:
+   * clientNoContextTakeover: false
+   * serverNoContextTakeover: false
+   * clientMaxWindowBits: 15
+   * serverMaxWindowBits: 15
+   */
+  static const CompressionOptions DEFAULT = const CompressionOptions();
+
+  /**
+   * Disables WebSocket Compression.
+   */
+  static const CompressionOptions OFF = const CompressionOptions(enabled: false);

[Søren Gjesse, 2015/06/25 15:41:26]

Long line, see
https://www.dartlang.org/articles/style-guide/#avoid-lines-longer-than-80-cha....

+
+  /**
+   * Control whether the client will reuse it's compression instances.
+   */
+  final bool clientNoContextTakeover;
+
+  /**
+   * Control whether the server will reuse it's compression instances.
+   */
+  final bool serverNoContextTakeover;
+
+  /**
+   * Sets the Max Window Bits for the Client.
+   */
+  final int clientMaxWindowBits;
+
+  /**
+   * Sets the Max Window Bits for the Server.
+   */
+  final int serverMaxWindowBits;
+
+  /**
+   * Enables or disables WebSocket compression.
+   */
+  final bool enabled;
+
+  const CompressionOptions({this.clientNoContextTakeover: false,

[Søren Gjesse, 2015/06/25 15:41:26]

Please reformat the arguments, see
https://www.dartlang.org/articles/style-guide/#do-indent-continued-lines-with....

+    this.serverNoContextTakeover: false, this.clientMaxWindowBits,
+                           this.serverMaxWindowBits, this.enabled: true});
+
+  /**
+   * Create a Compression Header
+   */
+  String _createHeader([List<String> requested]) {
+    if (!enabled) {
+      return "";
+    }
+
+    var header = "permessage-deflate";
+
+    if (requested == null) {
+      header += "; client_max_window_bits";
+    } else {
+      if (requested.contains("client_max_window_bits")) {
+        var myMaxWindowBits = clientMaxWindowBits == null ? 15 : clientMaxWindowBits;

[Søren Gjesse, 2015/06/25 15:41:26]

Long line.

+        header += "; client_max_window_bits=${myMaxWindowBits}";
+      }
+    }
+
+    if (clientNoContextTakeover && (requested != null

[Søren Gjesse, 2015/06/25 15:41:27]

Please look at
https://www.dartlang.org/articles/style-guide/#do-place-binary-operators-on-t...
regarding formatting of binary operators.

+      && requested.contains("client_no_context_takeover"))) {
+      header += "; client_no_context_takeover";
+    }
+
+    if (serverNoContextTakeover && (requested != null
+      && requested.contains("server_no_context_takeover"))) {
+      header += "; server_no_context_takeover";
+    }
+
+    if (requested != null) {
+      var mwb = serverMaxWindowBits == null ? 15 : serverMaxWindowBits;
+      header += "; server_max_window_bits=${mwb}";
+    }
+
+    return header;
+  }
+}
+
+/**
  * The [WebSocketTransformer] provides the ability to upgrade a
  * [HttpRequest] to a [WebSocket] connection. It supports both
  * upgrading a single [HttpRequest] and upgrading a stream of
  * [HttpRequest]s.
  *
  * To upgrade a single [HttpRequest] use the static [upgrade] method.
  *
  *     HttpServer server;
  *     server.listen((request) {
  *       if (...) {
@@ skipping 19 matching lines @@
 
   /**
    * Create a new [WebSocketTransformer].
    *
    * If [protocolSelector] is provided, [protocolSelector] will be called to
    * select what protocol to use, if any were provided by the client.
    * [protocolSelector] is should return either a [String] or a [Future]
    * completing with a [String]. The [String] must exist in the list of
    * protocols.
    */
-  factory WebSocketTransformer({protocolSelector(List<String> protocols)})
-      => new _WebSocketTransformerImpl(protocolSelector);
+  factory WebSocketTransformer({protocolSelector(List<String> protocols),
+    CompressionOptions compression: CompressionOptions.DEFAULT})
+      => new _WebSocketTransformerImpl(protocolSelector, compression);
 
   /**
    * Upgrades a [HttpRequest] to a [WebSocket] connection. If the
    * request is not a valid WebSocket upgrade request an HTTP response
    * with status code 500 will be returned. Otherwise the returned
    * future will complete with the [WebSocket] when the upgrade pocess
    * is complete.
    *
    * If [protocolSelector] is provided, [protocolSelector] will be called to
    * select what protocol to use, if any were provided by the client.
    * [protocolSelector] is should return either a [String] or a [Future]
    * completing with a [String]. The [String] must exist in the list of
    * protocols.
    */
   static Future<WebSocket> upgrade(HttpRequest request,
-                                   {protocolSelector(List<String> protocols)}) {
-    return _WebSocketTransformerImpl._upgrade(request, protocolSelector);
+                                   {protocolSelector(List<String> protocols),
+                                    CompressionOptions compression: CompressionOptions.DEFAULT}) {
+    return _WebSocketTransformerImpl._upgrade(request, protocolSelector, compression);
   }
 
   /**
    * Checks whether the request is a valid WebSocket upgrade request.
    */
   static bool isUpgradeRequest(HttpRequest request) {
     return _WebSocketTransformerImpl._isUpgradeRequest(request);
   }
 }
 
@@ skipping 74 matching lines @@
    * [WebSocketTransformer.upgrade]. To manually upgrade an [HttpRequest],
    * [HttpRequest.detachSocket] may be called.
    *
    * [protocol] should be the protocol negotiated by this handshake, if any.
    *
    * [serverSide] must be passed explicitly. If it's `false`, the WebSocket will
    * act as the client and mask the messages it sends. If it's `true`, it will
    * act as the server and will not mask its messages.
    */
   factory WebSocket.fromUpgradedSocket(Socket socket, {String protocol,
-        bool serverSide}) {
+        bool serverSide, CompressionOptions compression: CompressionOptions.DEFAULT}) {
     if (serverSide == null) {
       throw new ArgumentError("The serverSide argument must be passed "
           "explicitly to WebSocket.fromUpgradedSocket.");
     }
-    return new _WebSocketImpl._fromSocket(socket, protocol, serverSide);
+    return new _WebSocketImpl._fromSocket(socket, protocol, compression, serverSide);
   }
 
   /**
    * Returns the current state of the connection.
    */
   int get readyState;
 
   /**
    * The extensions property is initially the empty string. After the
    * WebSocket connection is established this string reflects the
@@ skipping 42 matching lines @@
    */
   Future addStream(Stream stream);
 }
 
 
 class WebSocketException implements IOException {
   final String message;
   const WebSocketException([this.message = ""]);
   String toString() => "WebSocketException: $message";
 }