FilePath: Remove most of ToWStringHack, adding a LossyDisplayName()

chrome/common/extensions/extension_file_util.cc

 // Copyright (c) 2011 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 "chrome/common/extensions/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 143 matching lines @@
     DictionaryValue* images_value = extension->GetThemeImages();
     if (images_value) {
       for (DictionaryValue::key_iterator iter = images_value->begin_keys();
            iter != images_value->end_keys(); ++iter) {
         std::string val;
         if (images_value->GetStringWithoutPathExpansion(*iter, &val)) {
           FilePath image_path = extension->path().AppendASCII(val);
           if (!file_util::PathExists(image_path)) {
             *error =
                 l10n_util::GetStringFUTF8(IDS_EXTENSION_INVALID_IMAGE_PATH,
-                    WideToUTF16(image_path.ToWStringHack()));
+                                          image_path.LossyDisplayName());
             return false;
           }
         }
       }
     }
 
     // Themes cannot contain other extension types.
     return true;
   }
 
@@ skipping 21 matching lines @@
     }
   }
 
   // Validate claimed plugin paths.
   for (size_t i = 0; i < extension->plugins().size(); ++i) {
     const Extension::PluginInfo& plugin = extension->plugins()[i];
     if (!file_util::PathExists(plugin.path)) {
       *error =
           l10n_util::GetStringFUTF8(
               IDS_EXTENSION_LOAD_PLUGIN_PATH_FAILED,
-              WideToUTF16(plugin.path.ToWStringHack()));
+              plugin.path.LossyDisplayName());
       return false;
     }
   }
 
   // Validate icon location for page actions.
   ExtensionAction* page_action = extension->page_action();
   if (page_action) {
     std::vector<std::string> icon_paths(*page_action->icon_paths());
     if (!page_action->default_icon_path().empty())
       icon_paths.push_back(page_action->default_icon_path());
@@ skipping 26 matching lines @@
 
   // Validate background page location.
   if (!extension->background_url().is_empty()) {
     FilePath page_path = ExtensionURLToRelativeFilePath(
         extension->background_url());
     const FilePath path = extension->GetResource(page_path).GetFilePath();
     if (path.empty() || !file_util::PathExists(path)) {
       *error =
           l10n_util::GetStringFUTF8(
               IDS_EXTENSION_LOAD_BACKGROUND_PAGE_FAILED,
-              WideToUTF16(page_path.ToWStringHack()));
+              page_path.LossyDisplayName());
       return false;
     }
   }
 
   // Validate path to the options page.  Don't check the URL for hosted apps,
   // because they are expected to refer to an external URL.
   if (!extension->options_url().is_empty() && !extension->is_hosted_app()) {
     const FilePath options_path = ExtensionURLToRelativeFilePath(
         extension->options_url());
     const FilePath path = extension->GetResource(options_path).GetFilePath();
     if (path.empty() || !file_util::PathExists(path)) {
       *error =
           l10n_util::GetStringFUTF8(
               IDS_EXTENSION_LOAD_OPTIONS_PAGE_FAILED,
-              WideToUTF16(options_path.ToWStringHack()));
+              options_path.LossyDisplayName());
       return false;
     }
   }
 
   // Validate sidebar default page location.
   ExtensionSidebarDefaults* sidebar_defaults = extension->sidebar_defaults();
   if (sidebar_defaults && sidebar_defaults->default_page().is_valid()) {
     FilePath page_path = ExtensionURLToRelativeFilePath(
         sidebar_defaults->default_page());
     const FilePath path = extension->GetResource(page_path).GetFilePath();
     if (path.empty() || !file_util::PathExists(path)) {
       *error =
           l10n_util::GetStringFUTF8(
               IDS_EXTENSION_LOAD_SIDEBAR_PAGE_FAILED,
-              WideToUTF16(page_path.ToWStringHack()));
+              page_path.LossyDisplayName());
       return false;
     }
   }
 
   // Validate locale info.
   if (!ValidateLocaleInfo(*extension, error))
     return false;
 
   // Check children of extension root to see if any of them start with _ and is
   // not on the reserved list.
@@ skipping 11 matching lines @@
   if (!file_util::DirectoryExists(install_directory))
     return;
 
   VLOG(1) << "Garbage collecting extensions...";
   file_util::FileEnumerator enumerator(install_directory,
                                        false,  // Not recursive.
                                        file_util::FileEnumerator::DIRECTORIES);
   FilePath extension_path;
   for (extension_path = enumerator.Next(); !extension_path.value().empty();
        extension_path = enumerator.Next()) {
-    std::string extension_id = WideToASCII(
-        extension_path.BaseName().ToWStringHack());
+    std::string extension_id = UTF16ToASCII(
+        extension_path.BaseName().LossyDisplayName());

[Avi (use Gerrit), 2011/02/04 19:24:53]

So this will DCHECK when a user puts a stupidly-named directory in his
extensions dir? Not fond of that. Need moar paranoia.

[evanm, 2011/02/04 19:37:12]

I guess DCHECKing is OK, since it is breaking an assertion that might be
interesting at development-time.  And the code below handles the bad path for
non-debug builds.

[Avi (use Gerrit), 2011/02/04 19:42:32]

I think I have a different expectation of what a DCHECK is for than you do.

I thought a DCHECK was to catch programmer error. If the code is processing
random crap under the user's control, it's OK to complain in a log, but I don't
think it's OK to allow bad user data to cause a DCHECK.

[evanm, 2011/02/04 19:58:50]

OK, I wrote some more thorough checking.

 
     // Delete directories that aren't valid IDs.
     if (!Extension::IdIsValid(extension_id)) {
       LOG(WARNING) << "Invalid extension ID encountered in extensions "
                       "directory: " << extension_id;
       VLOG(1) << "Deleting invalid extension directory "
-              << WideToASCII(extension_path.ToWStringHack()) << ".";
+              << extension_path.LossyDisplayName() << ".";
       file_util::Delete(extension_path, true);  // Recursive.
       continue;
     }
 
     std::map<std::string, FilePath>::const_iterator iter =
         extension_paths.find(extension_id);
 
     // If there is no entry in the prefs file, just delete the directory and
     // move on. This can legitimately happen when an uninstall does not
     // complete, for example, when a plugin is in use at uninstall time.
     if (iter == extension_paths.end()) {
       VLOG(1) << "Deleting unreferenced install for directory "
-              << WideToASCII(extension_path.ToWStringHack()) << ".";
+              << extension_path.LossyDisplayName() << ".";
       file_util::Delete(extension_path, true);  // Recursive.
       continue;
     }
 
     // Clean up old version directories.
     file_util::FileEnumerator versions_enumerator(
         extension_path,
         false,  // Not recursive.
         file_util::FileEnumerator::DIRECTORIES);
     for (FilePath version_dir = versions_enumerator.Next();
          !version_dir.value().empty();
          version_dir = versions_enumerator.Next()) {
       if (version_dir.BaseName() != iter->second.BaseName()) {
         VLOG(1) << "Deleting old version for directory "
-                << WideToASCII(version_dir.ToWStringHack()) << ".";
+                << version_dir.LossyDisplayName() << ".";
         file_util::Delete(version_dir, true);  // Recursive.
       }
     }
   }
 }
 
 ExtensionMessageBundle* LoadExtensionMessageBundle(
     const FilePath& extension_path,
     const std::string& default_locale,
     std::string* error) {
@@ skipping 59 matching lines @@
     if (extension_l10n_util::ShouldSkipValidation(path, locale_path,
                                                   all_locales))
       continue;
 
     FilePath messages_path =
         locale_path.Append(Extension::kMessagesFilename);
 
     if (!file_util::PathExists(messages_path)) {
       *error = base::StringPrintf(
           "%s %s", errors::kLocalesMessagesFileMissing,
-          WideToUTF8(messages_path.ToWStringHack()).c_str());
+          UTF16ToUTF8(messages_path.LossyDisplayName()).c_str());

[Mark Mentovai, 2011/02/04 19:26:58]

:(

       return false;
     }
 
     if (locale_path == default_locale_path)
       has_default_locale_message_file = true;
   }
 
   // Only message file for default locale has to exist.
   if (!has_default_locale_message_file) {
     *error = errors::kLocalesNoDefaultMessages;
     return false;
   }
 
   return true;
 }
 
 static bool IsScriptValid(const FilePath& path,
                           const FilePath& relative_path,
                           int message_id,
                           std::string* error) {
   std::string content;
   if (!file_util::PathExists(path) ||
       !file_util::ReadFileToString(path, &content)) {
     *error = l10n_util::GetStringFUTF8(
         message_id,
-        WideToUTF16(relative_path.ToWStringHack()));
+        relative_path.LossyDisplayName());
     return false;
   }
 
   if (!IsStringUTF8(content)) {
     *error = l10n_util::GetStringFUTF8(
         IDS_EXTENSION_BAD_FILE_ENCODING,
-        WideToUTF16(relative_path.ToWStringHack()));
+        relative_path.LossyDisplayName());
     return false;
   }
 
   return true;
 }
 
 bool CheckForIllegalFilenames(const FilePath& extension_path,
                               std::string* error) {
   // Reserved underscore names.
   static const FilePath::CharType* reserved_names[] = {
@@ skipping 122 matching lines @@
                             result,
                             NUM_DIRECTORY_CREATION_RESULTS);
 
   if (result == SUCCESS)
     return temp_path;
 
   return FilePath();
 }
 
 }  // namespace extension_file_util