Clang format slam.

net/http/http_util.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.
 
 // The rules for parsing content-types were borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_util.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.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 "base/time/time.h"
 
-
 namespace net {
 
 // Helpers --------------------------------------------------------------------
 
 // Returns the index of the closing quote of the string, if any.  |start| points
 // at the opening quote.
 static size_t FindStringEnd(const std::string& line, size_t start, char delim) {
   DCHECK_LT(start, line.length());
   DCHECK_EQ(line[start], delim);
   DCHECK((delim == '"') || (delim == '\''));
 
-  const char set[] = { delim, '\\', '\0' };
+  const char set[] = {delim, '\\', '\0'};
   for (size_t end = line.find_first_of(set, start + 1);
-       end != std::string::npos; end = line.find_first_of(set, end + 2)) {
+       end != std::string::npos;
+       end = line.find_first_of(set, end + 2)) {
     if (line[end] != '\\')
       return end;
   }
   return line.length();
 }
 
-
 // HttpUtil -------------------------------------------------------------------
 
 // static
 size_t HttpUtil::FindDelimiter(const std::string& line,
                                size_t search_start,
                                char delimiter) {
   do {
     // search_start points to the spot from which we should start looking
     // for the delimiter.
-    const char delim_str[] = { delimiter, '"', '\'', '\0' };
+    const char delim_str[] = {delimiter, '"', '\'', '\0'};
     size_t cur_delim_pos = line.find_first_of(delim_str, search_start);
     if (cur_delim_pos == std::string::npos)
       return line.length();
 
     char ch = line[cur_delim_pos];
     if (ch == delimiter) {
       // Found delimiter
       return cur_delim_pos;
     }
 
@@ skipping 30 matching lines @@
   if (type_end == std::string::npos)
     type_end = content_type_str.length();
 
   size_t charset_val = 0;
   size_t charset_end = 0;
   bool type_has_charset = false;
 
   // Iterate over parameters
   size_t param_start = content_type_str.find_first_of(';', type_end);
   if (param_start != std::string::npos) {
-    base::StringTokenizer tokenizer(begin + param_start, content_type_str.end(),
-                                    ";");
+    base::StringTokenizer tokenizer(
+        begin + param_start, content_type_str.end(), ";");
     tokenizer.set_quote_chars("\"");
     while (tokenizer.GetNext()) {
       std::string::const_iterator equals_sign =
           std::find(tokenizer.token_begin(), tokenizer.token_end(), '=');
       if (equals_sign == tokenizer.token_end())
         continue;
 
       std::string::const_iterator param_name_begin = tokenizer.token_begin();
       std::string::const_iterator param_name_end = equals_sign;
       TrimLWS(&param_name_begin, &param_name_end);
 
       std::string::const_iterator param_value_begin = equals_sign + 1;
       std::string::const_iterator param_value_end = tokenizer.token_end();
       DCHECK(param_value_begin <= tokenizer.token_end());
       TrimLWS(&param_value_begin, &param_value_end);
 
       if (LowerCaseEqualsASCII(param_name_begin, param_name_end, "charset")) {
         // TODO(abarth): Refactor this function to consistently use iterators.
         charset_val = param_value_begin - begin;
         charset_end = param_value_end - begin;
         type_has_charset = true;
-      } else if (LowerCaseEqualsASCII(param_name_begin, param_name_end,
-                                      "boundary")) {
+      } else if (LowerCaseEqualsASCII(
+                     param_name_begin, param_name_end, "boundary")) {
         if (boundary)
           boundary->assign(param_value_begin, param_value_end);
       }
     }
   }
 
   if (type_has_charset) {
     // Trim leading and trailing whitespace from charset_val.  We include
     // '(' in the trailing trim set to catch media-type comments, which are
     // not at all standard, but may occur in rare cases.
     charset_val = content_type_str.find_first_not_of(HTTP_LWS, charset_val);
     charset_val = std::min(charset_val, charset_end);
     char first_char = content_type_str[charset_val];
     if (first_char == '"' || first_char == '\'') {
       charset_end = FindStringEnd(content_type_str, charset_val, first_char);
       ++charset_val;
       DCHECK(charset_end >= charset_val);
     } else {
-      charset_end = std::min(content_type_str.find_first_of(HTTP_LWS ";(",
-                                                            charset_val),
-                             charset_end);
+      charset_end =
+          std::min(content_type_str.find_first_of(HTTP_LWS ";(", charset_val),
+                   charset_end);
     }
   }
 
   // if the server sent "*/*", it is meaningless, so do not store it.
   // also, if type_val is the same as mime_type, then just update the
   // charset.  however, if charset is empty and mime_type hasn't
   // changed, then don't wipe-out an existing charset.  We
   // also want to reject a mime-type if it does not include a slash.
   // some servers give junk after the charset parameter, which may
   // include a comma, so this check makes us a bit more tolerant.
-  if (content_type_str.length() != 0 &&
-      content_type_str != "*/*" &&
+  if (content_type_str.length() != 0 && content_type_str != "*/*" &&
       content_type_str.find_first_of('/') != std::string::npos) {
     // Common case here is that mime_type is empty
-    bool eq = !mime_type->empty() && LowerCaseEqualsASCII(begin + type_val,
-                                                          begin + type_end,
-                                                          mime_type->data());
+    bool eq = !mime_type->empty() &&
+              LowerCaseEqualsASCII(
+                  begin + type_val, begin + type_end, mime_type->data());
     if (!eq) {
       mime_type->assign(begin + type_val, begin + type_end);
       StringToLowerASCII(mime_type);
     }
     if ((!eq && *had_charset) || type_has_charset) {
       *had_charset = true;
       charset->assign(begin + charset_val, begin + charset_end);
       StringToLowerASCII(charset);
     }
   }
@@ skipping 29 matching lines @@
 
 // static
 bool HttpUtil::ParseRangeHeader(const std::string& ranges_specifier,
                                 std::vector<HttpByteRange>* ranges) {
   size_t equal_char_offset = ranges_specifier.find('=');
   if (equal_char_offset == std::string::npos)
     return false;
 
   // Try to extract bytes-unit part.
   std::string::const_iterator bytes_unit_begin = ranges_specifier.begin();
-  std::string::const_iterator bytes_unit_end = bytes_unit_begin +
-                                               equal_char_offset;
+  std::string::const_iterator bytes_unit_end =
+      bytes_unit_begin + equal_char_offset;
   std::string::const_iterator byte_range_set_begin = bytes_unit_end + 1;
   std::string::const_iterator byte_range_set_end = ranges_specifier.end();
 
   TrimLWS(&bytes_unit_begin, &bytes_unit_end);
   // "bytes" unit identifier is not found.
   if (!LowerCaseEqualsASCII(bytes_unit_begin, bytes_unit_end, "bytes"))
     return false;
 
-  ValuesIterator byte_range_set_iterator(byte_range_set_begin,
-                                         byte_range_set_end, ',');
+  ValuesIterator byte_range_set_iterator(
+      byte_range_set_begin, byte_range_set_end, ',');
   while (byte_range_set_iterator.GetNext()) {
     size_t minus_char_offset = byte_range_set_iterator.value().find('-');
     // If '-' character is not found, reports failure.
     if (minus_char_offset == std::string::npos)
       return false;
 
     std::string::const_iterator first_byte_pos_begin =
         byte_range_set_iterator.value_begin();
     std::string::const_iterator first_byte_pos_end =
-        first_byte_pos_begin +  minus_char_offset;
+        first_byte_pos_begin + minus_char_offset;
     TrimLWS(&first_byte_pos_begin, &first_byte_pos_end);
     std::string first_byte_pos(first_byte_pos_begin, first_byte_pos_end);
 
     HttpByteRange range;
     // Try to obtain first-byte-pos.
     if (!first_byte_pos.empty()) {
       int64 first_byte_position = -1;
       if (!base::StringToInt64(first_byte_pos, &first_byte_position))
         return false;
       range.set_first_byte_position(first_byte_position);
@@ skipping 48 matching lines @@
     return false;
 
   return true;
 }
 
 namespace {
 // A header string containing any of the following fields will cause
 // an error. The list comes from the XMLHttpRequest standard.
 // http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader-method
 const char* const kForbiddenHeaderFields[] = {
-  "accept-charset",
-  "accept-encoding",
-  "access-control-request-headers",
-  "access-control-request-method",
-  "connection",
-  "content-length",
-  "cookie",
-  "cookie2",
-  "content-transfer-encoding",
-  "date",
-  "expect",
-  "host",
-  "keep-alive",
-  "origin",
-  "referer",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade",
-  "user-agent",
-  "via",
+    "accept-charset",                 "accept-encoding",
+    "access-control-request-headers", "access-control-request-method",
+    "connection",                     "content-length",
+    "cookie",                         "cookie2",
+    "content-transfer-encoding",      "date",
+    "expect",                         "host",
+    "keep-alive",                     "origin",
+    "referer",                        "te",
+    "trailer",                        "transfer-encoding",
+    "upgrade",                        "user-agent",
+    "via",
 };
 }  // anonymous namespace
 
 // static
 bool HttpUtil::IsSafeHeader(const std::string& name) {
   std::string lower_name(StringToLowerASCII(name));
   if (StartsWithASCII(lower_name, "proxy-", true) ||
       StartsWithASCII(lower_name, "sec-", true))
     return false;
   for (size_t i = 0; i < arraysize(kForbiddenHeaderFields); ++i) {
     if (lower_name == kForbiddenHeaderFields[i])
       return false;
   }
   return true;
 }
 
 // static
 std::string HttpUtil::StripHeaders(const std::string& headers,
                                    const char* const headers_to_remove[],
                                    size_t headers_to_remove_len) {
   std::string stripped_headers;
   net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\r\n");
 
   while (it.GetNext()) {
     bool should_remove = false;
     for (size_t i = 0; i < headers_to_remove_len; ++i) {
-      if (LowerCaseEqualsASCII(it.name_begin(), it.name_end(),
-                               headers_to_remove[i])) {
+      if (LowerCaseEqualsASCII(
+              it.name_begin(), it.name_end(), headers_to_remove[i])) {
         should_remove = true;
         break;
       }
     }
     if (!should_remove) {
       // Assume that name and values are on the same line.
       stripped_headers.append(it.name_begin(), it.values_end());
       stripped_headers.append("\r\n");
     }
   }
   return stripped_headers;
 }
 
 // static
 bool HttpUtil::IsNonCoalescingHeader(std::string::const_iterator name_begin,
                                      std::string::const_iterator name_end) {
   // NOTE: "set-cookie2" headers do not support expires attributes, so we don't
   // have to list them here.
   const char* kNonCoalescingHeaders[] = {
-    "date",
-    "expires",
-    "last-modified",
-    "location",  // See bug 1050541 for details
-    "retry-after",
-    "set-cookie",
-    // The format of auth-challenges mixes both space separated tokens and
-    // comma separated properties, so coalescing on comma won't work.
-    "www-authenticate",
-    "proxy-authenticate",
-    // STS specifies that UAs must not process any STS headers after the first
-    // one.
-    "strict-transport-security"
-  };
+      "date",                     "expires",            "last-modified",
+      "location",  // See bug 1050541 for details
+      "retry-after",              "set-cookie",
+      // The format of auth-challenges mixes both space separated tokens and
+      // comma separated properties, so coalescing on comma won't work.
+      "www-authenticate",         "proxy-authenticate",
+      // STS specifies that UAs must not process any STS headers after the first
+      // one.
+      "strict-transport-security"};
   for (size_t i = 0; i < arraysize(kNonCoalescingHeaders); ++i) {
     if (LowerCaseEqualsASCII(name_begin, name_end, kNonCoalescingHeaders[i]))
       return true;
   }
   return false;
 }
 
 bool HttpUtil::IsLWS(char c) {
   return strchr(HTTP_LWS, c) != NULL;
 }
@@ skipping 15 matching lines @@
   return c == '"' || c == '\'';
 }
 
 // See RFC 2616 Sec 2.2 for the definition of |token|.
 bool HttpUtil::IsToken(std::string::const_iterator begin,
                        std::string::const_iterator end) {
   if (begin == end)
     return false;
   for (std::string::const_iterator iter = begin; iter != end; ++iter) {
     unsigned char c = *iter;
-    if (c >= 0x80 || c <= 0x1F || c == 0x7F ||
-        c == '(' || c == ')' || c == '<' || c == '>' || c == '@' ||
-        c == ',' || c == ';' || c == ':' || c == '\\' || c == '"' ||
-        c == '/' || c == '[' || c == ']' || c == '?' || c == '=' ||
-        c == '{' || c == '}' || c == ' ' || c == '\t')
+    if (c >= 0x80 || c <= 0x1F || c == 0x7F || c == '(' || c == ')' ||
+        c == '<' || c == '>' || c == '@' || c == ',' || c == ';' || c == ':' ||
+        c == '\\' || c == '"' || c == '/' || c == '[' || c == ']' || c == '?' ||
+        c == '=' || c == '{' || c == '}' || c == ' ' || c == '\t')
       return false;
   }
   return true;
 }
 
 std::string HttpUtil::Unquote(std::string::const_iterator begin,
                               std::string::const_iterator end) {
   // Empty string
   if (begin == end)
     return std::string();
@@ skipping 216 matching lines @@
   unsigned int qvalue10 = 10;
   base::StringTokenizer t(raw_language_list, ",");
   std::string lang_list_with_q;
   while (t.GetNext()) {
     std::string language = t.token();
     if (qvalue10 == 10) {
       // q=1.0 is implicit.
       lang_list_with_q = language;
     } else {
       DCHECK_LT(qvalue10, 10U);
-      base::StringAppendF(&lang_list_with_q, ",%s;q=0.%d", language.c_str(),
-                          qvalue10);
+      base::StringAppendF(
+          &lang_list_with_q, ",%s;q=0.%d", language.c_str(), qvalue10);
     }
     // It does not make sense to have 'q=0'.
     if (qvalue10 > kQvalueDecrement10)
       qvalue10 -= kQvalueDecrement10;
   }
   return lang_list_with_q;
 }
 
 void HttpUtil::AppendHeaderIfMissing(const char* header_name,
                                      const std::string& header_value,
@@ skipping 41 matching lines @@
 // ones are not sent in practice, to reduce upload size & memory use.
 
 enum {
   HISTOGRAM_MIN_HTTP_STATUS_CODE = 100,
   HISTOGRAM_MAX_HTTP_STATUS_CODE = 599,
 };
 
 // static
 std::vector<int> HttpUtil::GetStatusCodesForHistogram() {
   std::vector<int> codes;
-  codes.reserve(
-      HISTOGRAM_MAX_HTTP_STATUS_CODE - HISTOGRAM_MIN_HTTP_STATUS_CODE + 2);
+  codes.reserve(HISTOGRAM_MAX_HTTP_STATUS_CODE -
+                HISTOGRAM_MIN_HTTP_STATUS_CODE + 2);
   codes.push_back(0);
   for (int i = HISTOGRAM_MIN_HTTP_STATUS_CODE;
-       i <= HISTOGRAM_MAX_HTTP_STATUS_CODE; ++i)
+       i <= HISTOGRAM_MAX_HTTP_STATUS_CODE;
+       ++i)
     codes.push_back(i);
   return codes;
 }
 
 // static
 int HttpUtil::MapStatusCodeForHistogram(int code) {
   if (HISTOGRAM_MIN_HTTP_STATUS_CODE <= code &&
       code <= HISTOGRAM_MAX_HTTP_STATUS_CODE)
     return code;
   return 0;
@@ skipping 93 matching lines @@
     char delimiter)
     : props_(begin, end, delimiter),
       valid_(true),
       name_begin_(end),
       name_end_(end),
       value_begin_(end),
       value_end_(end),
       value_is_quoted_(false) {
 }
 
-HttpUtil::NameValuePairsIterator::~NameValuePairsIterator() {}
+HttpUtil::NameValuePairsIterator::~NameValuePairsIterator() {
+}
 
 // We expect properties to be formatted as one of:
 //   name="value"
 //   name='value'
 //   name='\'value\''
 //   name=value
 //   name = value
 //   name=
 // Due to buggy implementations found in some embedded devices, we also
 // accept values with missing close quotemark (http://crbug.com/39836):
@@ skipping 43 matching lines @@
       value_is_quoted_ = true;
       // Do not store iterators into this. See declaration of unquoted_value_.
       unquoted_value_ = HttpUtil::Unquote(value_begin_, value_end_);
     }
   }
 
   return true;
 }
 
 }  // namespace net