[WebSocket] Fix permessage-deflate handshake failure messages.

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>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "crypto/random.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_body_drainer.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_stream_parser.h"
@@ skipping 186 matching lines @@
   } else if (requested_sub_protocols.size() > 0 && count == 0) {
     *failure_message =
         "Sent non-empty 'Sec-WebSocket-Protocol' header "
         "but no response was received";
     return false;
   }
   *sub_protocol = value;
   return true;
 }
 
+bool DeflateError(std::string* message, const base::StringPiece& piece) {
+  *message = "Error in permessage-deflate: ";
+  AppendToString(piece, message);
+  return false;
+}
+
 bool ValidatePerMessageDeflateExtension(const WebSocketExtension& extension,
                                         std::string* failure_message,
                                         WebSocketExtensionParams* params) {
   static const char kClientPrefix[] = "client_";
   static const char kServerPrefix[] = "server_";
   static const char kNoContextTakeover[] = "no_context_takeover";
   static const char kMaxWindowBits[] = "max_window_bits";
   const size_t kPrefixLen = arraysize(kClientPrefix) - 1;
   COMPILE_ASSERT(kPrefixLen == arraysize(kServerPrefix) - 1,
                  the_strings_server_and_client_must_be_the_same_length);
   typedef std::vector<WebSocketExtension::Parameter> ParameterVector;
 
   DCHECK_EQ("permessage-deflate", extension.name());
   const ParameterVector& parameters = extension.parameters();
   std::set<std::string> seen_names;
   for (ParameterVector::const_iterator it = parameters.begin();
        it != parameters.end(); ++it) {
     const std::string& name = it->name();
     if (seen_names.count(name) != 0) {
-      *failure_message =
-          "Received duplicate permessage-deflate extension parameter " + name;
-      return false;
+      return DeflateError(
+          failure_message,
+          "Received duplicate permessage-deflate extension parameter " + name);
     }
     seen_names.insert(name);
     const std::string client_or_server(name, 0, kPrefixLen);
     const bool is_client = (client_or_server == kClientPrefix);
     if (!is_client && client_or_server != kServerPrefix) {
-      *failure_message =
-          "Received an unexpected permessage-deflate extension parameter";
-      return false;
+      return DeflateError(
+          failure_message,
+          "Received an unexpected permessage-deflate extension parameter");
     }
     const std::string rest(name, kPrefixLen);
     if (rest == kNoContextTakeover) {
       if (it->HasValue()) {
-        *failure_message = "Received invalid " + name + " parameter";
-        return false;
+        return DeflateError(failure_message,
+                            "Received invalid " + name + " parameter");
       }
       if (is_client)
         params->deflate_mode = WebSocketDeflater::DO_NOT_TAKE_OVER_CONTEXT;
     } else if (rest == kMaxWindowBits) {
-      if (!it->HasValue()) {
-        *failure_message = name + " must have value";
-        return false;
-      }
+      if (!it->HasValue())
+        return DeflateError(failure_message, name + " must have value");
       int bits = 0;
       if (!base::StringToInt(it->value(), &bits) || bits < 8 || bits > 15 ||
           it->value()[0] == '0' ||
           it->value().find_first_not_of("0123456789") != std::string::npos) {
-        *failure_message = "Received invalid " + name + " parameter";
-        return false;
+        return DeflateError(failure_message,
+                            "Received invalid " + name + " parameter");
       }
       if (is_client)
         params->client_window_bits = bits;
     } else {
-      *failure_message =
-          "Received an unexpected permessage-deflate extension parameter";
-      return false;
+      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* failure_message,
@@ skipping 304 matching lines @@
                          &extensions_,
                          &failure_message_,
                          extension_params_.get())) {
     return OK;
   }
   failure_message_ = "Error during WebSocket handshake: " + failure_message_;
   return ERR_INVALID_RESPONSE;
 }
 
 }  // namespace net