Clang format slam.

net/websockets/websocket_handshake_handler.cc

 // Copyright (c) 2012 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_handshake_handler.h"
 
 #include <limits>
 
 #include "base/base64.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/websockets/websocket_handshake_constants.h"
 #include "url/gurl.h"
 
 namespace net {
 namespace {
 
 const int kVersionHeaderValueForRFC6455 = 13;
 
 // Splits |handshake_message| into Status-Line or Request-Line (including CRLF)
 // and headers (excluding 2nd CRLF of double CRLFs at the end of a handshake
 // response).
-void ParseHandshakeHeader(
-    const char* handshake_message, int len,
-    std::string* request_line,
-    std::string* headers) {
+void ParseHandshakeHeader(const char* handshake_message,
+                          int len,
+                          std::string* request_line,
+                          std::string* headers) {
   size_t i = base::StringPiece(handshake_message, len).find_first_of("\r\n");
   if (i == base::StringPiece::npos) {
     *request_line = std::string(handshake_message, len);
     *headers = "";
     return;
   }
   // |request_line| includes \r\n.
   *request_line = std::string(handshake_message, i + 2);
 
   int header_len = len - (i + 2) - 2;
   if (header_len > 0) {
     // |handshake_message| includes trailing \r\n\r\n.
     // |headers| doesn't include 2nd \r\n.
     *headers = std::string(handshake_message + i + 2, header_len);
   } else {
     *headers = "";
   }
 }
 
 void FetchHeaders(const std::string& headers,
                   const char* const headers_to_get[],
                   size_t headers_to_get_len,
                   std::vector<std::string>* values) {
   net::HttpUtil::HeadersIterator iter(headers.begin(), headers.end(), "\r\n");
   while (iter.GetNext()) {
     for (size_t i = 0; i < headers_to_get_len; i++) {
-      if (LowerCaseEqualsASCII(iter.name_begin(), iter.name_end(),
-                               headers_to_get[i])) {
+      if (LowerCaseEqualsASCII(
+              iter.name_begin(), iter.name_end(), headers_to_get[i])) {
         values->push_back(iter.values());
       }
     }
   }
 }
 
 bool GetHeaderName(std::string::const_iterator line_begin,
                    std::string::const_iterator line_end,
                    std::string::const_iterator* name_begin,
                    std::string::const_iterator* name_end) {
   std::string::const_iterator colon = std::find(line_begin, line_end, ':');
   if (colon == line_end) {
     return false;
   }
   *name_begin = line_begin;
   *name_end = colon;
   if (*name_begin == *name_end || net::HttpUtil::IsLWS(**name_begin))
     return false;
   net::HttpUtil::TrimLWS(name_begin, name_end);
   return true;
 }
 
 // Similar to HttpUtil::StripHeaders, but it preserves malformed headers, that
 // is, lines that are not formatted as "<name>: <value>\r\n".
-std::string FilterHeaders(
-    const std::string& headers,
-    const char* const headers_to_remove[],
-    size_t headers_to_remove_len) {
+std::string FilterHeaders(const std::string& headers,
+                          const char* const headers_to_remove[],
+                          size_t headers_to_remove_len) {
   std::string filtered_headers;
 
   base::StringTokenizer lines(headers.begin(), headers.end(), "\r\n");
   while (lines.GetNext()) {
     std::string::const_iterator line_begin = lines.token_begin();
     std::string::const_iterator line_end = lines.token_end();
     std::string::const_iterator name_begin;
     std::string::const_iterator name_end;
     bool should_remove = false;
     if (GetHeaderName(line_begin, line_end, &name_begin, &name_end)) {
       for (size_t i = 0; i < headers_to_remove_len; ++i) {
         if (LowerCaseEqualsASCII(name_begin, name_end, headers_to_remove[i])) {
           should_remove = true;
           break;
         }
       }
     }
     if (!should_remove) {
       filtered_headers.append(line_begin, line_end);
       filtered_headers.append("\r\n");
     }
   }
   return filtered_headers;
 }
 
 bool CheckVersionInRequest(const std::string& request_headers) {
   std::vector<std::string> values;
   const char* const headers_to_get[1] = {
-    websockets::kSecWebSocketVersionLowercase};
+      websockets::kSecWebSocketVersionLowercase};
   FetchHeaders(request_headers, headers_to_get, 1, &values);
   DCHECK_LE(values.size(), 1U);
   if (values.empty())
     return false;
 
   int version;
   bool conversion_success = base::StringToInt(values[0], &version);
   if (!conversion_success)
     return false;
 
@@ skipping 16 matching lines @@
   response_message->reserve(response_message->size() + extra_size);
   response_message->append(header.begin(), header.end());
   response_message->append(kColonSpace, kColonSpace + kColonSpaceSize);
   response_message->append(value.begin(), value.end());
   response_message->append(kCrNl, kCrNl + kCrNlSize);
 }
 
 }  // namespace
 
 WebSocketHandshakeRequestHandler::WebSocketHandshakeRequestHandler()
-    : original_length_(0),
-      raw_length_(0) {}
+    : original_length_(0), raw_length_(0) {
+}
 
-bool WebSocketHandshakeRequestHandler::ParseRequest(
-    const char* data, int length) {
+bool WebSocketHandshakeRequestHandler::ParseRequest(const char* data,
+                                                    int length) {
   DCHECK_GT(length, 0);
   std::string input(data, length);
   int input_header_length =
       HttpUtil::LocateEndOfHeaders(input.data(), input.size(), 0);
   if (input_header_length <= 0)
     return false;
 
-  ParseHandshakeHeader(input.data(),
-                       input_header_length,
-                       &request_line_,
-                       &headers_);
+  ParseHandshakeHeader(
+      input.data(), input_header_length, &request_line_, &headers_);
 
   if (!CheckVersionInRequest(headers_)) {
     NOTREACHED();
     return false;
   }
 
   original_length_ = input_header_length;
   return true;
 }
 
 size_t WebSocketHandshakeRequestHandler::original_length() const {
   return original_length_;
 }
 
 void WebSocketHandshakeRequestHandler::AppendHeaderIfMissing(
-    const std::string& name, const std::string& value) {
+    const std::string& name,
+    const std::string& value) {
   DCHECK(!headers_.empty());
   HttpUtil::AppendHeaderIfMissing(name.c_str(), value, &headers_);
 }
 
 void WebSocketHandshakeRequestHandler::RemoveHeaders(
     const char* const headers_to_remove[],
     size_t headers_to_remove_len) {
   DCHECK(!headers_.empty());
-  headers_ = FilterHeaders(
-      headers_, headers_to_remove, headers_to_remove_len);
+  headers_ = FilterHeaders(headers_, headers_to_remove, headers_to_remove_len);
 }
 
 HttpRequestInfo WebSocketHandshakeRequestHandler::GetRequestInfo(
-    const GURL& url, std::string* challenge) {
+    const GURL& url,
+    std::string* challenge) {
   HttpRequestInfo request_info;
   request_info.url = url;
   size_t method_end = base::StringPiece(request_line_).find_first_of(" ");
   if (method_end != base::StringPiece::npos)
     request_info.method = std::string(request_line_.data(), method_end);
 
   request_info.extra_headers.Clear();
   request_info.extra_headers.AddHeadersFromString(headers_);
 
   request_info.extra_headers.RemoveHeader(websockets::kUpgrade);
   request_info.extra_headers.RemoveHeader(HttpRequestHeaders::kConnection);
 
   std::string key;
-  bool header_present = request_info.extra_headers.GetHeader(
-      websockets::kSecWebSocketKey, &key);
+  bool header_present =
+      request_info.extra_headers.GetHeader(websockets::kSecWebSocketKey, &key);
   DCHECK(header_present);
   request_info.extra_headers.RemoveHeader(websockets::kSecWebSocketKey);
   *challenge = key;
   return request_info;
 }
 
 bool WebSocketHandshakeRequestHandler::GetRequestHeaderBlock(
     const GURL& url,
     SpdyHeaderBlock* headers,
     std::string* challenge,
@@ skipping 73 matching lines @@
   raw_length_ = raw_request.size();
   return raw_request;
 }
 
 size_t WebSocketHandshakeRequestHandler::raw_length() const {
   DCHECK_GT(raw_length_, 0);
   return raw_length_;
 }
 
 WebSocketHandshakeResponseHandler::WebSocketHandshakeResponseHandler()
-    : original_header_length_(0) {}
+    : original_header_length_(0) {
+}
 
-WebSocketHandshakeResponseHandler::~WebSocketHandshakeResponseHandler() {}
+WebSocketHandshakeResponseHandler::~WebSocketHandshakeResponseHandler() {
+}
 
-size_t WebSocketHandshakeResponseHandler::ParseRawResponse(
-    const char* data, int length) {
+size_t WebSocketHandshakeResponseHandler::ParseRawResponse(const char* data,
+                                                           int length) {
   DCHECK_GT(length, 0);
   if (HasResponse()) {
     DCHECK(!status_line_.empty());
     // headers_ might be empty for wrong response from server.
 
     return 0;
   }
 
   size_t old_original_length = original_.size();
 
   original_.append(data, length);
   // TODO(ukai): fail fast when response gives wrong status code.
-  original_header_length_ = HttpUtil::LocateEndOfHeaders(
-      original_.data(), original_.size(), 0);
+  original_header_length_ =
+      HttpUtil::LocateEndOfHeaders(original_.data(), original_.size(), 0);
   if (!HasResponse())
     return length;
 
-  ParseHandshakeHeader(original_.data(),
-                       original_header_length_,
-                       &status_line_,
-                       &headers_);
+  ParseHandshakeHeader(
+      original_.data(), original_header_length_, &status_line_, &headers_);
   int header_size = status_line_.size() + headers_.size();
   DCHECK_GE(original_header_length_, header_size);
   header_separator_ = std::string(original_.data() + header_size,
                                   original_header_length_ - header_size);
   return original_header_length_ - old_original_length;
 }
 
 bool WebSocketHandshakeResponseHandler::HasResponse() const {
   return original_header_length_ > 0 &&
-      static_cast<size_t>(original_header_length_) <= original_.size();
+         static_cast<size_t>(original_header_length_) <= original_.size();
 }
 
-void ComputeSecWebSocketAccept(const std::string& key,
-                               std::string* accept) {
+void ComputeSecWebSocketAccept(const std::string& key, std::string* accept) {
   DCHECK(accept);
 
-  std::string hash =
-      base::SHA1HashString(key + websockets::kWebSocketGuid);
+  std::string hash = base::SHA1HashString(key + websockets::kWebSocketGuid);
   base::Base64Encode(hash, accept);
 }
 
 bool WebSocketHandshakeResponseHandler::ParseResponseInfo(
     const HttpResponseInfo& response_info,
     const std::string& challenge) {
   if (!response_info.headers.get())
     return false;
 
   // TODO(ricea): Eliminate all the reallocations and string copies.
   std::string response_message;
   response_message = response_info.headers->GetStatusLine();
   response_message += "\r\n";
 
-  AppendHeader(websockets::kUpgrade,
-               websockets::kWebSocketLowercase,
-               &response_message);
+  AppendHeader(
+      websockets::kUpgrade, websockets::kWebSocketLowercase, &response_message);
 
   AppendHeader(
       HttpRequestHeaders::kConnection, websockets::kUpgrade, &response_message);
 
   std::string websocket_accept;
   ComputeSecWebSocketAccept(challenge, &websocket_accept);
   AppendHeader(
       websockets::kSecWebSocketAccept, websocket_accept, &response_message);
 
   void* iter = NULL;
   std::string name;
   std::string value;
   while (response_info.headers->EnumerateHeaderLines(&iter, &name, &value)) {
     AppendHeader(name, value, &response_message);
   }
   response_message += "\r\n";
 
-  return ParseRawResponse(response_message.data(),
-                          response_message.size()) == response_message.size();
+  return ParseRawResponse(response_message.data(), response_message.size()) ==
+         response_message.size();
 }
 
 bool WebSocketHandshakeResponseHandler::ParseResponseHeaderBlock(
     const SpdyHeaderBlock& headers,
     const std::string& challenge,
     int spdy_protocol_version) {
   SpdyHeaderBlock::const_iterator status;
   if (spdy_protocol_version <= 2)
     status = headers.find("status");
   else
@@ skipping 46 matching lines @@
            LowerCaseEqualsASCII(iter->first,
                                 websockets::kSecWebSocketExtensionsSpdy3)))
         AppendHeader(iter->first.substr(1), tval, &response_message);
       else
         AppendHeader(iter->first, tval, &response_message);
       start = end + 1;
     } while (end != std::string::npos);
   }
   response_message += "\r\n";
 
-  return ParseRawResponse(response_message.data(),
-                          response_message.size()) == response_message.size();
+  return ParseRawResponse(response_message.data(), response_message.size()) ==
+         response_message.size();
 }
 
 void WebSocketHandshakeResponseHandler::GetHeaders(
     const char* const headers_to_get[],
     size_t headers_to_get_len,
     std::vector<std::string>* values) {
   DCHECK(HasResponse());
   DCHECK(!status_line_.empty());
   // headers_ might be empty for wrong response from server.
   if (headers_.empty())
@@ skipping 21 matching lines @@
 
 std::string WebSocketHandshakeResponseHandler::GetResponse() {
   DCHECK(HasResponse());
   DCHECK(!status_line_.empty());
   // headers_ might be empty for wrong response from server.
 
   return status_line_ + headers_ + header_separator_;
 }
 
 }  // namespace net