Consolidate most of net/'s icu_string_conversions.h dependencies.

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/i18n/icu_string_conversions.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"
-#include "third_party/icu/source/common/unicode/ucnv.h"
 
 namespace {
 
 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.
@@ skipping 31 matching lines @@
 }
 
 // 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)))
+        base::Base64Decode(part, &decoded) : DecodeQEncoding(part, &decoded))) {
     return false;
+  }

[mef, 2014/04/28 20:27:42]

is it better with braces?

[mmenke, 2014/04/28 20:45:03]

My understanding (From reading a long thread on chromium-dev from quite a while
back) is that the consensus style is to use braces when either the if-body or
if-antecedent takes more than one line.

 
   if (decoded.empty()) {
     output->clear();
     return true;
   }
 
-  UErrorCode err = U_ZERO_ERROR;
-  UConverter* converter(ucnv_open(charset.c_str(), &err));
-  if (U_FAILURE(err))
-    return false;
-
-  // A single byte in a legacy encoding can be expanded to 3 bytes in UTF-8.
-  // A 'two-byte character' in a legacy encoding can be expanded to 4 bytes
-  // in UTF-8. Therefore, the expansion ratio is 3 at most. Add one for a
-  // trailing '\0'.
-  size_t output_length = decoded.length() * 3 + 1;
-  char* buf = WriteInto(output, output_length);
-  output_length = ucnv_toAlgorithmic(UCNV_UTF8, converter, buf, output_length,
-                                     decoded.data(), decoded.length(), &err);
-  ucnv_close(converter);
-  if (U_FAILURE(err))
-    return false;
-  output->resize(output_length);
-  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() &&
-          base::CodepageToUTF16(encoded_word, referrer_charset.c_str(),
-                                base::OnStringConversionError::FAIL,
-                                &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 210 matching lines @@
 
   // RFC 5987 value should be ASCII-only.
   if (!IsStringASCII(value)) {
     decoded->clear();
     return true;
   }
 
   std::string unescaped = net::UnescapeURLComponent(
       value, net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS);
 
-  return base::ConvertToUtf8AndNormalize(unescaped, charset, decoded);
+  return net::ConvertToUtf8AndNormalize(unescaped, charset.c_str(), decoded);
 }
 
 } // namespace
 
 namespace net {
 
 HttpContentDisposition::HttpContentDisposition(
     const std::string& header, const std::string& referrer_charset)
   : type_(INLINE),
     parse_result_flags_(INVALID) {
@@ skipping 90 matching lines @@
 
   if (!ext_filename.empty())
     filename_ = ext_filename;
   else if (!filename.empty())
     filename_ = filename;
   else
     filename_ = name;
 }
 
 }  // namespace net