Clang format slam.

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 51 matching lines @@
   GET_HEADER_OK,
   GET_HEADER_MISSING,
   GET_HEADER_MULTIPLE,
 };
 
 std::string MissingHeaderMessage(const std::string& header_name) {
   return std::string("'") + header_name + "' header is missing";
 }
 
 std::string MultipleHeaderValuesMessage(const std::string& header_name) {
-  return
-      std::string("'") +
-      header_name +
-      "' header must not appear more than once in a response";
+  return std::string("'") + header_name +
+         "' header must not appear more than once in a response";
 }
 
 std::string GenerateHandshakeChallenge() {
   std::string raw_challenge(websockets::kRawChallengeLength, '\0');
   crypto::RandBytes(string_as_array(&raw_challenge), raw_challenge.length());
   std::string encoded_challenge;
   base::Base64Encode(raw_challenge, &encoded_challenge);
   return encoded_challenge;
 }
 
@@ skipping 32 matching lines @@
   }
   DCHECK_EQ(result, GET_HEADER_OK);
   return true;
 }
 
 bool ValidateUpgrade(const HttpResponseHeaders* headers,
                      std::string* failure_message) {
   std::string value;
   GetHeaderResult result =
       GetSingleHeaderValue(headers, websockets::kUpgrade, &value);
-  if (!ValidateHeaderHasSingleValue(result,
-                                    websockets::kUpgrade,
-                                    failure_message)) {
+  if (!ValidateHeaderHasSingleValue(
+          result, websockets::kUpgrade, failure_message)) {
     return false;
   }
 
   if (!LowerCaseEqualsASCII(value, websockets::kWebSocketLowercase)) {
-    *failure_message =
-        "'Upgrade' header value is not 'WebSocket': " + value;
+    *failure_message = "'Upgrade' header value is not 'WebSocket': " + value;
     return false;
   }
   return true;
 }
 
 bool ValidateSecWebSocketAccept(const HttpResponseHeaders* headers,
                                 const std::string& expected,
                                 std::string* failure_message) {
   std::string actual;
   GetHeaderResult result =
       GetSingleHeaderValue(headers, websockets::kSecWebSocketAccept, &actual);
-  if (!ValidateHeaderHasSingleValue(result,
-                                    websockets::kSecWebSocketAccept,
-                                    failure_message)) {
+  if (!ValidateHeaderHasSingleValue(
+          result, websockets::kSecWebSocketAccept, failure_message)) {
     return false;
   }
 
   if (expected != actual) {
     *failure_message = "Incorrect 'Sec-WebSocket-Accept' header value";
     return false;
   }
   return true;
 }
 
@@ skipping 35 matching lines @@
       has_invalid_protocol = true;
     if (++count > 1)
       has_multiple_protocols = true;
   }
 
   if (has_multiple_protocols) {
     *failure_message =
         MultipleHeaderValuesMessage(websockets::kSecWebSocketProtocol);
     return false;
   } else if (count > 0 && requested_sub_protocols.size() == 0) {
-    *failure_message =
-        std::string("Response must not include 'Sec-WebSocket-Protocol' "
-                    "header if not present in request: ")
-        + value;
+    *failure_message = std::string(
+                           "Response must not include 'Sec-WebSocket-Protocol' "
+                           "header if not present in request: ") +
+                       value;
     return false;
   } else if (has_invalid_protocol) {
-    *failure_message =
-        "'Sec-WebSocket-Protocol' header value '" +
-        value +
-        "' in response does not match any of sent values";
+    *failure_message = "'Sec-WebSocket-Protocol' header value '" + value +
+                       "' in response does not match any of sent values";
     return false;
   } 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;
 }
@@ skipping 13 matching lines @@
   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) {
+       it != parameters.end();
+       ++it) {
     const std::string& name = it->name();
     if (seen_names.count(name) != 0) {
       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) {
@@ skipping 36 matching lines @@
                         std::string* extensions,
                         std::string* failure_message,
                         WebSocketExtensionParams* params) {
   void* state = NULL;
   std::string value;
   std::vector<std::string> accepted_extensions;
   // TODO(ricea): If adding support for additional extensions, generalise this
   // code.
   bool seen_permessage_deflate = false;
   while (headers->EnumerateHeader(
-             &state, websockets::kSecWebSocketExtensions, &value)) {
+      &state, websockets::kSecWebSocketExtensions, &value)) {
     WebSocketExtensionParser parser;
     parser.Parse(value);
     if (parser.has_error()) {
       // TODO(yhirano) Set appropriate failure message.
       *failure_message =
           "'Sec-WebSocket-Extensions' header value is "
           "rejected by the parser: " +
           value;
       return false;
     }
     if (parser.extension().name() == "permessage-deflate") {
       if (seen_permessage_deflate) {
         *failure_message = "Received duplicate permessage-deflate response";
         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";
+      *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, ", ");
   return true;
 }
 
 }  // namespace
 
 WebSocketBasicHandshakeStream::WebSocketBasicHandshakeStream(
     scoped_ptr<ClientSocketHandle> connection,
     WebSocketStream::ConnectDelegate* connect_delegate,
     bool using_proxy,
     std::vector<std::string> requested_sub_protocols,
     std::vector<std::string> requested_extensions)
     : state_(connection.release(), using_proxy),
       connect_delegate_(connect_delegate),
       http_response_info_(NULL),
       requested_sub_protocols_(requested_sub_protocols),
-      requested_extensions_(requested_extensions) {}
+      requested_extensions_(requested_extensions) {
+}
 
-WebSocketBasicHandshakeStream::~WebSocketBasicHandshakeStream() {}
+WebSocketBasicHandshakeStream::~WebSocketBasicHandshakeStream() {
+}
 
 int WebSocketBasicHandshakeStream::InitializeStream(
     const HttpRequestInfo* request_info,
     RequestPriority priority,
     const BoundNetLog& net_log,
     const CompletionCallback& callback) {
   url_ = request_info->url;
   state_.Initialize(request_info, priority, net_log, callback);
   return OK;
 }
@@ skipping 111 matching lines @@
 
 void WebSocketBasicHandshakeStream::GetSSLInfo(SSLInfo* ssl_info) {
   parser()->GetSSLInfo(ssl_info);
 }
 
 void WebSocketBasicHandshakeStream::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   parser()->GetSSLCertRequestInfo(cert_request_info);
 }
 
-bool WebSocketBasicHandshakeStream::IsSpdyHttpStream() const { return false; }
+bool WebSocketBasicHandshakeStream::IsSpdyHttpStream() const {
+  return false;
+}
 
 void WebSocketBasicHandshakeStream::Drain(HttpNetworkSession* session) {
   HttpResponseBodyDrainer* drainer = new HttpResponseBodyDrainer(this);
   drainer->Start(session);
   // |drainer| will delete itself.
 }
 
 void WebSocketBasicHandshakeStream::SetPriority(RequestPriority priority) {
   // TODO(ricea): See TODO comment in HttpBasicStream::SetPriority(). If it is
   // gone, then copy whatever has happened there over here.
@@ skipping 100 matching lines @@
         std::string("Error during WebSocket handshake: ") + ErrorToString(rv);
     OnFinishOpeningHandshake();
     return rv;
   }
 }
 
 int WebSocketBasicHandshakeStream::ValidateUpgradeResponse(
     const HttpResponseHeaders* headers) {
   extension_params_.reset(new WebSocketExtensionParams);
   if (ValidateUpgrade(headers, &failure_message_) &&
-      ValidateSecWebSocketAccept(headers,
-                                 handshake_challenge_response_,
-                                 &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;
   }
   failure_message_ = "Error during WebSocket handshake: " + failure_message_;
   return ERR_INVALID_RESPONSE;
 }
 
 }  // namespace net