Optimize Websocket compression for no context takeover requests

tests/standalone/io/web_socket_compression_test.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.
 //
 // VMOptions=
 // VMOptions=--short_socket_read
 // VMOptions=--short_socket_write
 // VMOptions=--short_socket_read --short_socket_write
 
 import "dart:async";
@@ skipping 153 matching lines @@
 
       WebSocket.connect(url).then((websocket) {
         return websocket.listen((message) {
           Expect.equals("Hello", message);
           websocket.close();
         }).asFuture();
       }).then((_) => server.close());
     });
   }
 
-  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);
 
               webSocket.add(message);
               webSocket.close();
             });
         });
       });
 
       var url = '${secure ? "wss" : "ws"}://$HOST_NAME:${server.port}/';
@@ skipping 18 matching lines @@
           }).asFuture();
           websocket.add("Hello World");
           return future;
         }).then((_) {
           server.close();
           asyncEnd();
         });
     }); // 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();
     // compression no takeover
     testCompressionSupport(server: true, client: true);
     // compression and context takeover.
     testCompressionSupport(server: true, client: true, contextTakeover: true);
     // Compression on client but not server. No take over
     testCompressionSupport(client: true);
     // Compression on server but not client.
     testCompressionSupport(server: true);
 
     testCompressionHeaders();
     // Chrome headers
     testReturnHeaders('permessage-deflate; client_max_window_bits',
                       "permessage-deflate; client_max_window_bits=15");
     // Firefox headers
     testReturnHeaders('permessage-deflate',
                       "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);
   }
 }
 
 main() {
   new SecurityConfiguration(secure: false).runTests();
   // TODO(whesse): Make WebSocket.connect() take an optional context: parameter.
   // new SecurityConfiguration(secure: true).runTests();
 }