Support parsing a Sec-WebSocket-Extensions header with multiple elements

net/websockets/websocket_basic_handshake_stream.cc

 // Copyright 2013 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/websockets/websocket_basic_handshake_stream.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <string>
@@ skipping 285 matching lines @@
       return DeflateError(
           failure_message,
           "Received an unexpected permessage-deflate extension parameter");
     }
   }
   params->deflate_enabled = true;
   return true;
 }
 
 bool ValidateExtensions(const HttpResponseHeaders* headers,
-                        const std::vector<std::string>& requested_extensions,
-                        std::string* extensions,
+                        std::string* concatenated_header_value,

[yhirano, 2015/03/30 11:02:03]

Why did you change the name to concatenated_header_value? This function  checks
if the headers consist of valid WebSocket extensions, so |extensions| or
|accepted_exceptions| is a good name, I think.

[tyoshino (SeeGerritForStatus), 2015/03/31 06:17:44]

I want to
- emphasize that this variable holds a descriptor, not a WebSocketExtension
struct
- give a good pair of names to |accepted_extensions| and |extensions|. It's not
clear what |extensions| means as there's also |accepted_extensions|. It sounds
like that |extensions| is a list of not-yet-accepted extensions.

I couldn't come up with any good pair of names, so decided to just describe
what's done in this method. I gave it another try. PTAL.

                         std::string* failure_message,
                         WebSocketExtensionParams* params) {
   void* state = nullptr;
-  std::string value;
-  std::vector<std::string> accepted_extensions;
+  std::string header_value;
+  std::vector<std::string> header_values;
   // TODO(ricea): If adding support for additional extensions, generalise this
   // code.
   bool seen_permessage_deflate = false;
-  while (headers->EnumerateHeader(
-             &state, websockets::kSecWebSocketExtensions, &value)) {
+  while (headers->EnumerateHeader(&state, websockets::kSecWebSocketExtensions,
+                                  &header_value)) {
     WebSocketExtensionParser parser;
-    parser.Parse(value);
+    parser.Parse(header_value);
     if (parser.has_error()) {
       // TODO(yhirano) Set appropriate failure message.
       *failure_message =
           "'Sec-WebSocket-Extensions' header value is "
           "rejected by the parser: " +
-          value;
+          header_value;
       return false;
     }
-    if (parser.extension().name() == "permessage-deflate") {
-      if (seen_permessage_deflate) {
-        *failure_message = "Received duplicate permessage-deflate response";
+
+    const std::vector<WebSocketExtension>& extensions = parser.extensions();
+    for (size_t i = 0; i < extensions.size(); ++i) {
+      const WebSocketExtension& extension = extensions[i];
+      if (extension.name() == "permessage-deflate") {
+        if (seen_permessage_deflate) {
+          *failure_message = "Received duplicate permessage-deflate response";
+          return false;
+        }
+        seen_permessage_deflate = true;
+
+        if (!ValidatePerMessageDeflateExtension(extension, failure_message,
+                                                params))
+          return false;
+        header_values.push_back(header_value);
+      } else {
+        *failure_message = "Found an unsupported extension '" +
+                           extension.name() +
+                           "' in 'Sec-WebSocket-Extensions' header";
         return false;
       }
-      seen_permessage_deflate = true;
-      if (!ValidatePerMessageDeflateExtension(
-              parser.extension(), failure_message, params))
-        return false;
-    } else {
-      *failure_message =
-          "Found an unsupported extension '" +
-          parser.extension().name() +
-          "' in 'Sec-WebSocket-Extensions' header";
-      return false;
     }
-    accepted_extensions.push_back(value);
   }
-  *extensions = JoinString(accepted_extensions, ", ");
+  *concatenated_header_value = JoinString(header_values, ", ");
   return true;
 }
 
 }  // namespace
 
 WebSocketBasicHandshakeStream::WebSocketBasicHandshakeStream(
     scoped_ptr<ClientSocketHandle> connection,
     WebSocketStream::ConnectDelegate* connect_delegate,
     bool using_proxy,
     std::vector<std::string> requested_sub_protocols,
@@ skipping 272 matching lines @@
   std::string failure_message;
   if (ValidateUpgrade(headers, &failure_message) &&
       ValidateSecWebSocketAccept(
           headers, handshake_challenge_response_, &failure_message) &&
       ValidateConnection(headers, &failure_message) &&
       ValidateSubProtocol(headers,
                           requested_sub_protocols_,
                           &sub_protocol_,
                           &failure_message) &&
       ValidateExtensions(headers,
-                         requested_extensions_,
                          &extensions_,
                          &failure_message,
                          extension_params_.get())) {
     return OK;
   }
   set_failure_message("Error during WebSocket handshake: " + failure_message);
   return ERR_INVALID_RESPONSE;
 }
 
 void WebSocketBasicHandshakeStream::set_failure_message(
     const std::string& failure_message) {
   *failure_message_ = failure_message;
 }
 
 }  // namespace net