Optimize Websocket compression for no context takeover requests

tests/standalone/io/web_socket_compression_test.dart

Index: tests/standalone/io/web_socket_compression_test.dart
diff --git a/tests/standalone/io/web_socket_compression_test.dart b/tests/standalone/io/web_socket_compression_test.dart
index b1fd13ffd9fb36ab4bf6d8461071d52f37638353..912b855da3d9e24cdc64b0a49d762e75b104cc88 100644
--- a/tests/standalone/io/web_socket_compression_test.dart
+++ b/tests/standalone/io/web_socket_compression_test.dart
@@ -171,13 +171,15 @@ class SecurityConfiguration {
     });
   }
 
-  void testReturnHeaders(String headerValue, String expected) {
+  void testReturnHeaders(String headerValue, String expected, {
+    CompressionOptions serverCompression: CompressionOptions.DEFAULT}) {
     asyncStart();
     createServer().then((server) {
       server.listen((request) {
         // Stuff
         Expect.isTrue(WebSocketTransformer.isUpgradeRequest(request));
-        WebSocketTransformer.upgrade(request).then((webSocket) {
+        WebSocketTransformer.upgrade(request, compression: serverCompression)
+          .then((webSocket) {
             webSocket.listen((message) {
               Expect.equals("Hello World", message);
 
@@ -216,6 +218,47 @@ class SecurityConfiguration {
     }); // End createServer
   }
 
+  void testClientRequestHeaders(CompressionOptions compression) {
+    asyncStart();
+    createServer().then((server) {
+      server.listen((request) {
+        var extensionHeader = request.headers.value('Sec-WebSocket-Extensions');
+        var hv = HeaderValue.parse(extensionHeader);
+        Expect.equals(compression.serverNoContextTakeover,
+            hv.parameters.containsKey('server_no_context_takeover'));
+        Expect.equals(compression.clientNoContextTakeover,
+            hv.parameters.containsKey('client_no_context_takeover'));
+        Expect.equals(compression.serverMaxWindowBits?.toString(),
+            hv.parameters['server_max_window_bits']);
+        Expect.equals(compression.clientMaxWindowBits?.toString(),
+            hv.parameters['client_max_window_bits']);
+
+        WebSocketTransformer.upgrade(request).then((webSocket) {
+            webSocket.listen((message) {
+              Expect.equals('Hello World', message);
+
+              webSocket.add(message);
+              webSocket.close();
+            });
+        });
+      });
+
+      var url = '${secure ? "wss" : "ws"}://$HOST_NAME:${server.port}/';
+
+      WebSocket.connect(url, compression: compression).then((websocket) {
+        var future = websocket.listen((message) {
+          Expect.equals('Hello World', message);
+          websocket.close();
+        }).asFuture();
+        websocket.add('Hello World');

[Søren Gjesse, 2016/01/18 07:36:00]

With the different options of context take-over and discarding of encoders and
decoders I think testing sending of several messages would be beneficial. Please
make a separate change to extend the test.

+        return future;
+      }).then((_) {
+        server.close();
+        asyncEnd();
+      });
+    });
+  }
+
   void runTests() {
     // No compression or takeover
     testCompressionSupport();
@@ -237,9 +280,39 @@ class SecurityConfiguration {
                       "permessage-deflate; client_max_window_bits=15");
     // Ensure max_window_bits resize appropriately.
     testReturnHeaders('permessage-deflate; server_max_window_bits=10',
-                      "permessage-deflate;" 
+                      "permessage-deflate;"
                       " server_max_window_bits=10;"
                       " client_max_window_bits=10");
+    // Don't provider context takeover if requested but not enabled.
+    // Default is not enabled.
+    testReturnHeaders('permessage-deflate; client_max_window_bits;'
+                      'client_no_context_takeover',
+                      'permessage-deflate; client_max_window_bits=15');
+    // Enable context Takeover and provide if requested.
+    var compression = new CompressionOptions(clientNoContextTakeover: true,
+        serverNoContextTakeover: true);
+    testReturnHeaders('permessage-deflate; client_max_window_bits; '
+                      'client_no_context_takeover',
+                      'permessage-deflate; client_no_context_takeover; '
+                      'client_max_window_bits=15',
+                      serverCompression: compression);
+    // Enable context takeover and don't provide if not requested
+    compression = new CompressionOptions(clientNoContextTakeover: true,
+        serverNoContextTakeover: true);
+    testReturnHeaders('permessage-deflate; client_max_window_bits; ',
+                      'permessage-deflate; client_max_window_bits=15',
+                      serverCompression: compression);
+
+    compression = CompressionOptions.DEFAULT;
+    testClientRequestHeaders(compression);
+    compression = new CompressionOptions(clientNoContextTakeover: true,
+        serverNoContextTakeover: true);
+    testClientRequestHeaders(compression);
+    compression = new CompressionOptions(clientNoContextTakeover: true,
+        serverNoContextTakeover: true,
+        clientMaxWindowBits: 8,
+        serverMaxWindowBits: 8);
+    testClientRequestHeaders(compression);
   }
 }