Clang format slam.

net/http/http_content_disposition.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/http/http_content_disposition.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_string_util.h"
 #include "net/base/net_util.h"
 #include "net/http/http_util.h"
 
 namespace {
 
-enum RFC2047EncodingType {
-  Q_ENCODING,
-  B_ENCODING
-};
+enum RFC2047EncodingType { Q_ENCODING, B_ENCODING };
 
 // Decodes a "Q" encoded string as described in RFC 2047 section 4.2. Similar to
 // decoding a quoted-printable string.  Returns true if the input was valid.
 bool DecodeQEncoding(const std::string& input, std::string* output) {
   std::string temp;
   temp.reserve(input.size());
   for (std::string::const_iterator it = input.begin(); it != input.end();
        ++it) {
     if (*it == '_') {
       temp.push_back(' ');
     } else if (*it == '=') {
       if ((input.end() - it < 3) ||
           !IsHexDigit(static_cast<unsigned char>(*(it + 1))) ||
           !IsHexDigit(static_cast<unsigned char>(*(it + 2))))
         return false;
-      unsigned char ch = HexDigitToInt(*(it + 1)) * 16 +
-                         HexDigitToInt(*(it + 2));
+      unsigned char ch =
+          HexDigitToInt(*(it + 1)) * 16 + HexDigitToInt(*(it + 2));
       temp.push_back(static_cast<char>(ch));
       ++it;
       ++it;
     } else if (0x20 < *it && *it < 0x7F && *it != '?') {
       // In a Q-encoded word, only printable ASCII characters
       // represent themselves. Besides, space, '=', '_' and '?' are
       // not allowed, but they're already filtered out.
       DCHECK_NE('=', *it);
       DCHECK_NE('?', *it);
       DCHECK_NE('_', *it);
       temp.push_back(*it);
     } else {
       return false;
     }
   }
   output->swap(temp);
   return true;
 }
 
 // Decodes a "Q" or "B" encoded string as per RFC 2047 section 4. The encoding
 // type is specified in |enc_type|.
 bool DecodeBQEncoding(const std::string& part,
                       RFC2047EncodingType enc_type,
                       const std::string& charset,
                       std::string* output) {
   std::string decoded;
-  if (!((enc_type == B_ENCODING) ?
-        base::Base64Decode(part, &decoded) : DecodeQEncoding(part, &decoded))) {
+  if (!((enc_type == B_ENCODING) ? base::Base64Decode(part, &decoded)
+                                 : DecodeQEncoding(part, &decoded))) {
     return false;
   }
 
   if (decoded.empty()) {
     output->clear();
     return true;
   }
 
   return net::ConvertToUtf8(decoded, charset.c_str(), output);
 }
 
 bool DecodeWord(const std::string& encoded_word,
                 const std::string& referrer_charset,
                 bool* is_rfc2047,
                 std::string* output,
                 int* parse_result_flags) {
   *is_rfc2047 = false;
   output->clear();
   if (encoded_word.empty())
     return true;
 
   if (!IsStringASCII(encoded_word)) {
     // Try UTF-8, referrer_charset and the native OS default charset in turn.
     if (IsStringUTF8(encoded_word)) {
       *output = encoded_word;
     } else {
       base::string16 utf16_output;
       if (!referrer_charset.empty() &&
-          net::ConvertToUTF16(encoded_word, referrer_charset.c_str(),
-                              &utf16_output)) {
+          net::ConvertToUTF16(
+              encoded_word, referrer_charset.c_str(), &utf16_output)) {
         *output = base::UTF16ToUTF8(utf16_output);
       } else {
         *output = base::WideToUTF8(base::SysNativeMBToWide(encoded_word));
       }
     }
 
     *parse_result_flags |= net::HttpContentDisposition::HAS_NON_ASCII_STRINGS;
     return true;
   }
 
@@ skipping 71 matching lines @@
     // encoded_word ending prematurelly with '?' or extra '?'
     *is_rfc2047 = false;
     return false;
   }
 
   // We're not handling 'especial' characters quoted with '\', but
   // it should be Ok because we're not an email client but a
   // web browser.
 
   // What IE6/7 does: %-escaped UTF-8.
-  decoded_word = net::UnescapeURLComponent(encoded_word,
-                                           net::UnescapeRule::SPACES);
+  decoded_word =
+      net::UnescapeURLComponent(encoded_word, net::UnescapeRule::SPACES);
   if (decoded_word != encoded_word)
     *parse_result_flags |=
         net::HttpContentDisposition::HAS_PERCENT_ENCODED_STRINGS;
   if (IsStringUTF8(decoded_word)) {
     output->swap(decoded_word);
     return true;
     // We can try either the OS default charset or 'origin charset' here,
     // As far as I can tell, IE does not support it. However, I've seen
     // web servers emit %-escaped string in a legacy encoding (usually
     // origin charset).
@@ skipping 27 matching lines @@
       if (!is_previous_token_rfc2047)
         decoded_value.push_back(' ');
       continue;
     }
     // We don't support a single multibyte character split into
     // adjacent encoded words. Some broken mail clients emit headers
     // with that problem, but most web servers usually encode a filename
     // in a single encoded-word. Firefox/Thunderbird do not support
     // it, either.
     std::string decoded;
-    if (!DecodeWord(t.token(), referrer_charset, &is_previous_token_rfc2047,
-                    &decoded, &current_parse_result_flags))
+    if (!DecodeWord(t.token(),
+                    referrer_charset,
+                    &is_previous_token_rfc2047,
+                    &decoded,
+                    &current_parse_result_flags))
       return false;
     decoded_value.append(decoded);
   }
   output->swap(decoded_value);
   if (parse_result_flags && !output->empty())
     *parse_result_flags |= current_parse_result_flags;
   return true;
 }
 
 // Parses the charset and value-chars out of an ext-value string.
@@ skipping 71 matching lines @@
     decoded->clear();
     return true;
   }
 
   std::string unescaped = net::UnescapeURLComponent(
       value, net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS);
 
   return net::ConvertToUtf8AndNormalize(unescaped, charset.c_str(), decoded);
 }
 
-} // namespace
+}  // namespace
 
 namespace net {
 
 HttpContentDisposition::HttpContentDisposition(
-    const std::string& header, const std::string& referrer_charset)
-  : type_(INLINE),
-    parse_result_flags_(INVALID) {
+    const std::string& header,
+    const std::string& referrer_charset)
+    : type_(INLINE), parse_result_flags_(INVALID) {
   Parse(header, referrer_charset);
 }
 
 HttpContentDisposition::~HttpContentDisposition() {
 }
 
 std::string::const_iterator HttpContentDisposition::ConsumeDispositionType(
-    std::string::const_iterator begin, std::string::const_iterator end) {
+    std::string::const_iterator begin,
+    std::string::const_iterator end) {
   DCHECK(type_ == INLINE);
   std::string::const_iterator delimiter = std::find(begin, end, ';');
 
   std::string::const_iterator type_begin = begin;
   std::string::const_iterator type_end = delimiter;
   HttpUtil::TrimLWS(&type_begin, &type_end);
 
   // If the disposition-type isn't a valid token the then the
   // Content-Disposition header is malformed, and we treat the first bytes as
   // a parameter rather than a disposition-type.
@@ skipping 41 matching lines @@
   std::string::const_iterator pos = header.begin();
   std::string::const_iterator end = header.end();
   pos = ConsumeDispositionType(pos, end);
 
   std::string name;
   std::string filename;
   std::string ext_filename;
 
   HttpUtil::NameValuePairsIterator iter(pos, end, ';');
   while (iter.GetNext()) {
-    if (filename.empty() && LowerCaseEqualsASCII(iter.name_begin(),
-                                                 iter.name_end(),
-                                                 "filename")) {
-      DecodeFilenameValue(iter.value(), referrer_charset, &filename,
-                          &parse_result_flags_);
+    if (filename.empty() &&
+        LowerCaseEqualsASCII(iter.name_begin(), iter.name_end(), "filename")) {
+      DecodeFilenameValue(
+          iter.value(), referrer_charset, &filename, &parse_result_flags_);
       if (!filename.empty())
         parse_result_flags_ |= HAS_FILENAME;
-    } else if (name.empty() && LowerCaseEqualsASCII(iter.name_begin(),
-                                                    iter.name_end(),
-                                                    "name")) {
+    } else if (name.empty() &&
+               LowerCaseEqualsASCII(
+                   iter.name_begin(), iter.name_end(), "name")) {
       DecodeFilenameValue(iter.value(), referrer_charset, &name, NULL);
       if (!name.empty())
         parse_result_flags_ |= HAS_NAME;
-    } else if (ext_filename.empty() && LowerCaseEqualsASCII(iter.name_begin(),
-                                                            iter.name_end(),
-                                                            "filename*")) {
+    } else if (ext_filename.empty() &&
+               LowerCaseEqualsASCII(
+                   iter.name_begin(), iter.name_end(), "filename*")) {
       DecodeExtValue(iter.raw_value(), &ext_filename);
       if (!ext_filename.empty())
         parse_result_flags_ |= HAS_EXT_FILENAME;
     }
   }
 
   if (!ext_filename.empty())
     filename_ = ext_filename;
   else if (!filename.empty())
     filename_ = filename;
   else
     filename_ = name;
 }
 
 }  // namespace net