download filename fix

net/base/net_util.cc

 // Copyright (c) 2006-2008 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 <algorithm>
 #include <unicode/ucnv.h>
 #include <unicode/uidna.h>
 #include <unicode/ulocdata.h>
 #include <unicode/uniset.h>
 #include <unicode/uscript.h>
@@ skipping 229 matching lines @@
       decoded.data(), length, &err);
   ucnv_close(converter);
   if (U_FAILURE(err)) {
     return false;
   }
   output->resize(length);
   return true;
 }
 
 bool DecodeWord(const std::string& encoded_word,
+                const std::string& referrer_charset,
                 bool *is_rfc2047,
                 std::string* output) {
-  // TODO(jungshik) : Revisit this later. Do we want to pass through non-ASCII
-  // strings which can be mozibake?  WinHTTP converts a raw 8bit string
-  // UTF-16 assuming it's in the OS default encoding.
   if (!IsStringASCII(encoded_word)) {
-    // Try falling back to the NativeMB encoding if the raw input is not UTF-8.
+    // Try UTF-8, referrer_charset and the native OS default charset in turn.
     if (IsStringUTF8(encoded_word)) {
       *output = encoded_word;
     } else {
-      *output = WideToUTF8(base::SysNativeMBToWide(encoded_word));
+      std::wstring wide_output;
+      if (!referrer_charset.empty() &&
+          CodepageToWide(encoded_word, referrer_charset.c_str(),
+                         OnStringUtilConversionError::FAIL, &wide_output)) {
+        *output = WideToUTF8(wide_output);
+      } else {
+        *output = WideToUTF8(base::SysNativeMBToWide(encoded_word));
+      }
     }
     *is_rfc2047 = false;
     return true;
   }
 
   // RFC 2047 : one of encoding methods supported by Firefox and relatively
   // widely used by web servers.
   // =?charset?<E>?<encoded string>?= where '<E>' is either 'B' or 'Q'.
   // We don't care about the length restriction (72 bytes) because
   // many web servers generate encoded words longer than the limit.
@@ skipping 79 matching lines @@
     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).
     // TODO(jungshik) : Test IE further and consider adding a fallback here.
   }
   return false;
 }
 
-bool DecodeParamValue(const std::string& input, std::string* output) {
+bool DecodeParamValue(const std::string& input,
+                      const std::string& referrer_charset,
+                      std::string* output) {
   std::string tmp;
   // Tokenize with whitespace characters.
   StringTokenizer t(input, " \t\n\r");
   t.set_options(StringTokenizer::RETURN_DELIMS);
   bool is_previous_token_rfc2047 = true;
   while (t.GetNext()) {
     if (t.token_is_delim()) {
       // If the previous non-delimeter token is not RFC2047-encoded,
       // put in a space in its place. Otheriwse, skip over it.
       if (!is_previous_token_rfc2047) {
         tmp.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(), &is_previous_token_rfc2047, &decoded))
+    if (!DecodeWord(t.token(), referrer_charset, &is_previous_token_rfc2047,
+                    &decoded))
       return false;
     tmp.append(decoded);
   }
   output->swap(tmp);
   return true;
 }
 
 // TODO(mpcomplete): This is a quick and dirty implementation for now.  I'm
 // sure this doesn't properly handle all (most?) cases.
 template<typename STR>
@@ skipping 284 matching lines @@
 std::wstring GetSpecificHeader(const std::wstring& headers,
                                const std::wstring& name) {
   return GetSpecificHeaderT(headers, name);
 }
 
 std::string GetSpecificHeader(const std::string& headers,
                                const std::string& name) {
   return GetSpecificHeaderT(headers, name);
 }
 
-std::wstring GetFileNameFromCD(const std::string& header) {
+std::wstring GetFileNameFromCD(const std::string& header,
+                               const std::string& referrer_charset) {
   std::string param_value = GetHeaderParamValue(header, "filename");
   if (param_value.empty()) {
     // Some servers use 'name' parameter.
     param_value = GetHeaderParamValue(header, "name");
   }
   if (param_value.empty())
     return std::wstring();
   std::string decoded;
-  if (DecodeParamValue(param_value, &decoded))
+  if (DecodeParamValue(param_value, referrer_charset, &decoded))
     return UTF8ToWide(decoded);
   return std::wstring();
 }
 
 std::wstring GetHeaderParamValue(const std::wstring& field,
                                  const std::wstring& param_name) {
   return GetHeaderParamValueT(field, param_name);
 }
 
 std::string GetHeaderParamValue(const std::string& field,
@@ skipping 150 matching lines @@
 }
 
 std::wstring StripWWW(const std::wstring& text) {
   const std::wstring www(L"www.");
   return (text.compare(0, www.length(), www) == 0) ?
       text.substr(www.length()) : text;
 }
 
 std::wstring GetSuggestedFilename(const GURL& url,
                                   const std::string& content_disposition,
+                                  const std::string& referrer_charset,
                                   const std::wstring& default_name) {
-  std::wstring filename = GetFileNameFromCD(content_disposition);
+  std::wstring filename = GetFileNameFromCD(content_disposition,
+                                            referrer_charset);
   if (!filename.empty()) {
     // Remove any path information the server may have sent, take the name
     // only.
     filename = file_util::GetFilenameFromPath(filename);
     // Next, remove "." from the beginning and end of the file name to avoid
     // tricks with hidden files, "..", and "."
     TrimString(filename, L".", &filename);
   }
   if (filename.empty()) {
     if (url.is_valid()) {
@@ skipping 16 matching lines @@
       // TODO(jungshik) : Decode a 'punycoded' IDN hostname. (bug 1264451)
       filename = url.host().empty() ? L"download" : UTF8ToWide(url.host());
     } else
       NOTREACHED();
   }
 
   file_util::ReplaceIllegalCharacters(&filename, '-');
   return filename;
 }
 
-std::wstring GetSuggestedFilename(const GURL& url,
-                                  const std::wstring& content_disposition,
-                                  const std::wstring& default_name) {
-  return GetSuggestedFilename(
-      url, WideToUTF8(content_disposition), default_name);
-}
-
 bool IsPortAllowedByDefault(int port) {
   int array_size = arraysize(kRestrictedPorts);
   for (int i = 0; i < array_size; i++) {
     if (kRestrictedPorts[i] == port) {
       return false;
     }
   }
   return true;
 }
 
@@ skipping 100 matching lines @@
   char buffer[256];
   int result = gethostname(buffer, sizeof(buffer));
   if (result != 0) {
     DLOG(INFO) << "gethostname() failed with " << result;
     buffer[0] = '\0';
   }
   return std::string(buffer);
 }
 
 }  // namespace net