Download filename encoding fix [try2]:

net/base/net_util.cc

 // Copyright (c) 2010 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 <map>
 #include <unicode/ucnv.h>
 #include <unicode/uidna.h>
@@ skipping 254 matching lines @@
     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) {
+  *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 {
       std::wstring wide_output;
       if (!referrer_charset.empty() &&
           base::CodepageToWide(encoded_word, referrer_charset.c_str(),
                                base::OnStringConversionError::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.
   std::string tmp;
   *is_rfc2047 = true;
@@ skipping 773 matching lines @@
       FILE_PATH_LITERAL("download");
 
   // 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.SchemeIs("about") || url.SchemeIs("data")) {
     return default_name.empty() ? FilePath(kFinalFallbackName) : default_name;
   }
 
   const std::string filename_from_cd = GetFileNameFromCD(content_disposition,
-                                                          referrer_charset);
+                                                         referrer_charset);
 #if defined(OS_WIN)
   FilePath::StringType filename = UTF8ToWide(filename_from_cd);
 #elif defined(OS_POSIX)
   FilePath::StringType filename = filename_from_cd;
 #endif
 
   if (!filename.empty()) {
     // Remove any path information the server may have sent, take the name
     // only.
     filename = FilePath(filename).BaseName().value();
 
     // Next, remove "." from the beginning and end of the file name to avoid
     // tricks with hidden files, "..", and "."
     TrimString(filename, FILE_PATH_LITERAL("."), &filename);
   }
   if (filename.empty()) {
     if (url.is_valid()) {
       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,
+                   &decoded_filename);
+      }
+
 #if defined(OS_WIN)
-      filename = UTF8ToWide(unescaped_url_filename);
+      filename = UTF8ToWide(decoded_filename);
 #elif defined(OS_POSIX)
-      filename = unescaped_url_filename;
+      filename = decoded_filename;
 #endif
     }
   }
 
 #if defined(OS_WIN)
   { // Handle CreateFile() stripping trailing dots and spaces on filenames
     // http://support.microsoft.com/kb/115827
     std::string::size_type pos = filename.find_last_not_of(L" .");
     if (pos == std::string::npos)
       filename.resize(0);
@@ skipping 741 matching lines @@
     unsigned char mask = 0xFF << (8 - remaining_bits);
     int i = num_entire_bytes_in_prefix;
     if ((ip_number[i] & mask) != (ip_prefix[i] & mask))
       return false;
   }
 
   return true;
 }
 
 }  // namespace net