Fix WebSocketServer extension parser.

net/server/web_socket_encoder_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/server/web_socket_encoder.h"
+
+#include "net/websockets/websocket_deflate_parameters.h"
+#include "net/websockets/websocket_extension.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
+TEST(WebSocketEncoderHandshakeTest, EmptyRequestShouldBeRejected) {
+  WebSocketDeflateParameters params;
+  std::string failure_message;
+  scoped_ptr<WebSocketEncoder> server(
+      WebSocketEncoder::CreateServer("", &params, &failure_message));
+
+  EXPECT_FALSE(server);
+  EXPECT_EQ("Failed to parse extensions header.", failure_message);
+}
+
 TEST(WebSocketEncoderHandshakeTest,
      CreateServerWithoutClientMaxWindowBitsParameter) {
-  std::string response_extensions;
+  WebSocketDeflateParameters params;
+  std::string failure_message;
   scoped_ptr<WebSocketEncoder> server(WebSocketEncoder::CreateServer(
-      "permessage-deflate", &response_extensions));
-  // The response must not include client_max_window_bits if the client didn't
-  // declare that it accepts the parameter.
-  EXPECT_EQ("permessage-deflate; server_max_window_bits=15",
-            response_extensions);
+      "permessage-deflate", &params, &failure_message));
+
+  ASSERT_TRUE(server);
+  EXPECT_TRUE(server->deflate_enabled());
+  EXPECT_EQ("permessage-deflate", params.AsExtension().ToString());
 }
 
 TEST(WebSocketEncoderHandshakeTest,
      CreateServerWithServerNoContextTakeoverParameter) {
-  std::string response_extensions;
+  WebSocketDeflateParameters params;
+  std::string failure_message;
   scoped_ptr<WebSocketEncoder> server(WebSocketEncoder::CreateServer(
-      "permessage-deflate; server_no_context_takeover", &response_extensions));
-  EXPECT_EQ(
-      "permessage-deflate; server_max_window_bits=15"
-      "; server_no_context_takeover",
-      response_extensions);
+      "permessage-deflate; server_no_context_takeover", &params,
+      &failure_message));
+  ASSERT_TRUE(server);
+  EXPECT_TRUE(server->deflate_enabled());
+  EXPECT_EQ("permessage-deflate; server_no_context_takeover",
+            params.AsExtension().ToString());
+}
+
+TEST(WebSocketEncoderHandshakeTest, FirstExtensionShouldBeChosen) {
+  WebSocketDeflateParameters params;
+  std::string failure_message;
+  scoped_ptr<WebSocketEncoder> server(WebSocketEncoder::CreateServer(
+      "permessage-deflate; server_no_context_takeover,"
+      "permessage-deflate; server_max_window_bits=15",
+      &params, &failure_message));
+
+  ASSERT_TRUE(server);
+  EXPECT_TRUE(server->deflate_enabled());
+  EXPECT_EQ("permessage-deflate; server_no_context_takeover",
+            params.AsExtension().ToString());
+}
+
+TEST(WebSocketEncoderHandshakeTest, AllExtensionsShouldBeChecked) {
+  WebSocketDeflateParameters params;
+  std::string failure_message;
+  scoped_ptr<WebSocketEncoder> server(WebSocketEncoder::CreateServer(
+      "permessage-deflate; server_no_context_takeover,"
+      "permessage-deflate; Xserver_max_window_bits=15",
+      &params, &failure_message));
+
+  ASSERT_FALSE(server);
+  EXPECT_EQ("Received an unexpected permessage-deflate extension parameter",
+            failure_message);
 }
 
 class WebSocketEncoderTest : public testing::Test {
  public:
   WebSocketEncoderTest() {}
 
   void SetUp() override {
     std::string response_extensions;
-    server_.reset(WebSocketEncoder::CreateServer("", &response_extensions));
+    server_ = WebSocketEncoder::CreateServer();
     EXPECT_EQ(std::string(), response_extensions);
     client_.reset(WebSocketEncoder::CreateClient(""));
   }
 
  protected:
   scoped_ptr<WebSocketEncoder> server_;
   scoped_ptr<WebSocketEncoder> client_;
 };
 
 class WebSocketEncoderCompressionTest : public WebSocketEncoderTest {
  public:
   WebSocketEncoderCompressionTest() : WebSocketEncoderTest() {}
 
   void SetUp() override {
-    std::string response_extensions;
-    server_.reset(WebSocketEncoder::CreateServer(
-        "permessage-deflate; client_max_window_bits", &response_extensions));
-    EXPECT_EQ(
-        "permessage-deflate; server_max_window_bits=15; "
-        "client_max_window_bits=15",
-        response_extensions);
-    client_.reset(WebSocketEncoder::CreateClient(response_extensions));
+    WebSocketDeflateParameters params;
+    std::string failure_message;
+    server_ = WebSocketEncoder::CreateServer(
+        "permessage-deflate; client_max_window_bits", &params,
+        &failure_message);
+    ASSERT_TRUE(server_);
+
+    EXPECT_EQ("permessage-deflate; client_max_window_bits=8",
+              params.AsExtension().ToString());
+    client_.reset(
+        WebSocketEncoder::CreateClient(params.AsExtension().ToString()));
   }
 };
 
+TEST_F(WebSocketEncoderTest, DeflateDisabledEncoder) {
+  scoped_ptr<WebSocketEncoder> server(WebSocketEncoder::CreateServer());
+  scoped_ptr<WebSocketEncoder> client(WebSocketEncoder::CreateClient(""));
+
+  ASSERT_TRUE(server);
+  ASSERT_TRUE(client);
+
+  EXPECT_FALSE(server->deflate_enabled());
+  EXPECT_FALSE(client->deflate_enabled());
+}
+
 TEST_F(WebSocketEncoderTest, ClientToServer) {
   std::string frame("ClientToServer");
   int mask = 123456;
   std::string encoded;
   int bytes_consumed;
   std::string decoded;
 
   client_->EncodeFrame(frame, mask, &encoded);
   EXPECT_EQ(WebSocket::FRAME_OK,
             server_->DecodeFrame(encoded, &bytes_consumed, &decoded));
@@ skipping 94 matching lines @@
 
   server_->EncodeFrame(frame, mask, &encoded);
   EXPECT_LT(encoded.length(), frame.length());
   EXPECT_EQ(WebSocket::FRAME_OK,
             client_->DecodeFrame(encoded, &bytes_consumed, &decoded));
   EXPECT_EQ(frame, decoded);
   EXPECT_EQ((int)encoded.length(), bytes_consumed);
 }
 
 }  // namespace net