referrer_charset is a lie. It's really the user's default_charset.

net/base/net_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.
 
 #include "net/base/net_util.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 
@@ skipping 221 matching lines @@
   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;
 }
 
 bool DecodeWord(const std::string& encoded_word,
-                const std::string& referrer_charset,
+                const std::string& default_charset,
                 bool* is_rfc2047,
                 std::string* output) {
   *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.
+    // Try UTF-8, default_charset and the native OS default charset in turn.
     if (IsStringUTF8(encoded_word)) {
       *output = encoded_word;
     } else {
       string16 utf16_output;
-      if (!referrer_charset.empty() &&
-          base::CodepageToUTF16(encoded_word, referrer_charset.c_str(),
+      if (!default_charset.empty() &&
+          base::CodepageToUTF16(encoded_word, default_charset.c_str(),
                                 base::OnStringConversionError::FAIL,
                                 &utf16_output)) {
         *output = UTF16ToUTF8(utf16_output);
       } else {
         *output = WideToUTF8(base::SysNativeMBToWide(encoded_word));
       }
     }
 
     return true;
   }
@@ skipping 651 matching lines @@
     ReplaceSubstringsAfterOffset(&filename, 0, "\\", "_");
   }
 }
 
 // Returns the filename determined from the last component of the path portion
 // of the URL.  Returns an empty string if the URL doesn't have a path or is
 // invalid. If the generated filename is not reliable,
 // |should_overwrite_extension| will be set to true, in which case a better
 // extension should be determined based on the content type.
 std::string GetFileNameFromURL(const GURL& url,
-                               const std::string& referrer_charset,
+                               const std::string& default_charset,
                                bool* should_overwrite_extension) {
   // about: and data: URLs don't have file names, but esp. data: URLs may
   // contain parts that look like ones (i.e., contain a slash).  Therefore we
   // don't attempt to divine a file name out of them.
   if (!url.is_valid() || url.SchemeIs("about") || url.SchemeIs("data"))
     return std::string();
 
   const std::string unescaped_url_filename = UnescapeURLComponent(
       url.ExtractFileName(),
       UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
 
   // The URL's path should be escaped UTF-8, but may not be.
   std::string decoded_filename = unescaped_url_filename;
   if (!IsStringASCII(decoded_filename)) {
     bool ignore;
     // TODO(jshin): this is probably not robust enough. To be sure, we need
     // encoding detection.
-    DecodeWord(unescaped_url_filename, referrer_charset, &ignore,
+    DecodeWord(unescaped_url_filename, default_charset, &ignore,
                &decoded_filename);
   }
   // If the URL contains a (possibly empty) query, assume it is a generator, and
   // allow the determined extension to be overwritten.
   *should_overwrite_extension = !decoded_filename.empty() && url.has_query();
 
   return decoded_filename;
 }
 
 #if defined(OS_WIN)
@@ skipping 222 matching lines @@
   if (numDelimsSeen != 2)
     return false;
   if (temp_charset.empty() || temp_value.empty())
     return false;
   decoded_charset->swap(temp_charset);
   value->swap(temp_value);
   return true;
 }
 
 bool DecodeFilenameValue(const std::string& input,
-                         const std::string& referrer_charset,
+                         const std::string& default_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(), referrer_charset, &is_previous_token_rfc2047,
+    if (!DecodeWord(t.token(), default_charset, &is_previous_token_rfc2047,
                     &decoded))
       return false;
     tmp.append(decoded);
   }
   output->swap(tmp);
   return true;
 }
 
 bool DecodeExtValue(const std::string& param_value, std::string* decoded) {
   if (param_value.find('"') != std::string::npos)
@@ skipping 171 matching lines @@
       *file_path = FilePath(leaf_name);
     } else {
       *file_path = file_path->Append(leaf_name);
     }
   }
 #endif
 }
 
 string16 GetSuggestedFilename(const GURL& url,
                               const std::string& content_disposition,
-                              const std::string& referrer_charset,
+                              const std::string& default_charset,
                               const std::string& suggested_name,
                               const std::string& mime_type,
                               const std::string& default_name) {
   // TODO: this function to be updated to match the httpbis recommendations.
   // Talk to abarth for the latest news.
 
   // We don't translate this fallback string, "download". If localization is
   // needed, the caller should provide localized fallback in |default_name|.
   static const char* kFinalFallbackName = "download";
   std::string filename;  // In UTF-8
   bool overwrite_extension = false;
 
   // Try to extract a filename from content-disposition first.
   if (!content_disposition.empty()) {
-    HttpContentDisposition header(content_disposition, referrer_charset);
+    HttpContentDisposition header(content_disposition, default_charset);
     filename = header.filename();
   }
 
   // Then try to use the suggested name.
   if (filename.empty() && !suggested_name.empty())
     filename = suggested_name;
 
   // Now try extracting the filename from the URL.  GetFileNameFromURL() only
   // looks at the last component of the URL and doesn't return the hostname as a
   // failover.
   if (filename.empty())
-    filename = GetFileNameFromURL(url, referrer_charset, &overwrite_extension);
+    filename = GetFileNameFromURL(url, default_charset, &overwrite_extension);
 
   // Finally try the URL hostname, but only if there's no default specified in
   // |default_name|.  Some schemes (e.g.: file:, about:, data:) do not have a
   // host name.
   if (filename.empty() && default_name.empty() &&
       url.is_valid() && !url.host().empty()) {
     // TODO(jungshik) : Decode a 'punycoded' IDN hostname. (bug 1264451)
     filename = url.host();
   }
 
@@ skipping 31 matching lines @@
   std::string path = filename.empty() ? default_name : filename;
   file_util::ReplaceIllegalCharactersInPath(&path, '-');
   FilePath result(path);
   GenerateSafeFileName(mime_type, overwrite_extension, &result);
   return UTF8ToUTF16(result.value());
 #endif
 }
 
 FilePath GenerateFileName(const GURL& url,
                           const std::string& content_disposition,
-                          const std::string& referrer_charset,
+                          const std::string& default_charset,
                           const std::string& suggested_name,
                           const std::string& mime_type,
                           const std::string& default_file_name) {
   string16 file_name = GetSuggestedFilename(url,
                                             content_disposition,
-                                            referrer_charset,
+                                            default_charset,
                                             suggested_name,
                                             mime_type,
                                             default_file_name);
 
 #if defined(OS_WIN)
   FilePath generated_name(file_name);
 #else
   FilePath generated_name(base::SysWideToNativeMB(UTF16ToWide(file_name)));
 #endif
   DCHECK(!generated_name.empty());
@@ skipping 903 matching lines @@
 
 NetworkInterface::NetworkInterface(const std::string& name,
                                    const IPAddressNumber& address)
     : name(name), address(address) {
 }
 
 NetworkInterface::~NetworkInterface() {
 }
 
 }  // namespace net