Add utf_string_conversions to base namespace.

chrome/browser/enumerate_modules_model_win.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 "chrome/browser/enumerate_modules_model_win.h"
 
 #include <Tlhelp32.h>
 #include <wintrust.h>
 #include <algorithm>
 
@@ skipping 317 matching lines @@
     const ModuleEnumerator::Module& module,
     const ModuleEnumerator::BlacklistEntry& blacklisted) {
   // All modules must be normalized before matching against blacklist.
   DCHECK(module.normalized);
   // Filename is mandatory and version should not contain spaces.
   DCHECK(strlen(blacklisted.filename) > 0);
   DCHECK(!strstr(blacklisted.version_from, " "));
   DCHECK(!strstr(blacklisted.version_to, " "));
 
   std::string filename_hash, location_hash;
-  GenerateHash(WideToUTF8(module.name), &filename_hash);
-  GenerateHash(WideToUTF8(module.location), &location_hash);
+  GenerateHash(base::WideToUTF8(module.name), &filename_hash);
+  GenerateHash(base::WideToUTF8(module.location), &location_hash);
 
   // Filenames are mandatory. Location is mandatory if given.
   if (filename_hash == blacklisted.filename &&
           (std::string(blacklisted.location).empty() ||
           location_hash == blacklisted.location)) {
     // We have a name match against the blacklist (and possibly location match
     // also), so check version.
     Version module_version(UTF16ToASCII(module.version));
     Version version_min(blacklisted.version_from);
     Version version_max(blacklisted.version_to);
     bool version_ok = !version_min.IsValid() && !version_max.IsValid();
     if (!version_ok) {
       bool too_low = version_min.IsValid() &&
           (!module_version.IsValid() ||
           module_version.CompareTo(version_min) < 0);
       bool too_high = version_max.IsValid() &&
           (!module_version.IsValid() ||
           module_version.CompareTo(version_max) >= 0);
       version_ok = !too_low && !too_high;
     }
 
     if (version_ok) {
       // At this point, the names match and there is no version specified
       // or the versions also match.
 
       std::string desc_or_signer(blacklisted.desc_or_signer);
       std::string signer_hash, description_hash;
-      GenerateHash(WideToUTF8(module.digital_signer), &signer_hash);
-      GenerateHash(WideToUTF8(module.description), &description_hash);
+      GenerateHash(base::WideToUTF8(module.digital_signer), &signer_hash);
+      GenerateHash(base::WideToUTF8(module.description), &description_hash);
 
       // If signatures match (or both are empty), then we have a winner.
       if (signer_hash == desc_or_signer)
         return CONFIRMED_BAD;
 
       // If descriptions match (or both are empty) and the locations match, then
       // we also have a confirmed match.
       if (description_hash == desc_or_signer &&
           !location_hash.empty() && location_hash == blacklisted.location) {
         return CONFIRMED_BAD;
@@ skipping 220 matching lines @@
   env_vars.push_back(L"ProgramFiles");
   env_vars.push_back(L"ProgramData");
   env_vars.push_back(L"USERPROFILE");
   env_vars.push_back(L"SystemRoot");
   env_vars.push_back(L"TEMP");
   env_vars.push_back(L"TMP");
   env_vars.push_back(L"CommonProgramFiles");
   for (std::vector<string16>::const_iterator variable = env_vars.begin();
        variable != env_vars.end(); ++variable) {
     std::string path;
-    if (environment->GetVar(WideToASCII(*variable).c_str(), &path)) {
+    if (environment->GetVar(base::WideToASCII(*variable).c_str(), &path)) {
       path_mapping_.push_back(
           std::make_pair(base::i18n::ToLower(UTF8ToUTF16(path)) + L"\\",
                          L"%" + base::i18n::ToLower(*variable) + L"%"));
     }
   }
 }
 
 void ModuleEnumerator::CollapsePath(Module* entry) {
   // Take the path and see if we can use any of the substitution values
   // from the vector constructed above to replace c:\windows with, for
@@ skipping 207 matching lines @@
 
   for (ModuleEnumerator::ModulesVector::const_iterator module =
            enumerated_modules_.begin();
        module != enumerated_modules_.end(); ++module) {
     DictionaryValue* data = new DictionaryValue();
     data->SetInteger("type", module->type);
     string16 type_string;
     if ((module->type & ModuleEnumerator::LOADED_MODULE) == 0) {
       // Module is not loaded, denote type of module.
       if (module->type & ModuleEnumerator::SHELL_EXTENSION)
-        type_string = ASCIIToWide("Shell Extension");
+        type_string = base::ASCIIToWide("Shell Extension");
       if (module->type & ModuleEnumerator::WINSOCK_MODULE_REGISTRATION) {
         if (!type_string.empty())
-          type_string += ASCIIToWide(", ");
-        type_string += ASCIIToWide("Winsock");
+          type_string += base::ASCIIToWide(", ");
+        type_string += base::ASCIIToWide("Winsock");
       }
       // Must be one of the above type.
       DCHECK(!type_string.empty());
       if (!limited_mode_) {
-        type_string += ASCIIToWide(" -- ");
+        type_string += base::ASCIIToWide(" -- ");
         type_string += l10n_util::GetStringUTF16(IDS_CONFLICTS_NOT_LOADED_YET);
       }
     }
     data->SetString("type_description", type_string);
     data->SetInteger("status", module->status);
     data->SetString("location", module->location);
     data->SetString("name", module->name);
     data->SetString("product_name", module->product_name);
     data->SetString("description", module->description);
     data->SetString("version", module->version);
     data->SetString("digital_signer", module->digital_signer);
 
     if (!limited_mode_) {
       // Figure out the possible resolution help string.
       string16 actions;
-      string16 separator = ASCIIToWide(" ") + l10n_util::GetStringUTF16(
+      string16 separator = base::ASCIIToWide(" ") + l10n_util::GetStringUTF16(
           IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_SEPERATOR) +
-          ASCIIToWide(" ");
+          base::ASCIIToWide(" ");
 
       if (module->recommended_action & ModuleEnumerator::NONE) {
         actions = l10n_util::GetStringUTF16(
             IDS_CONFLICTS_CHECK_INVESTIGATING);
       }
       if (module->recommended_action & ModuleEnumerator::UNINSTALL) {
         if (!actions.empty())
           actions += separator;
         actions = l10n_util::GetStringUTF16(
             IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_UNINSTALL);
       }
       if (module->recommended_action & ModuleEnumerator::UPDATE) {
         if (!actions.empty())
           actions += separator;
         actions += l10n_util::GetStringUTF16(
             IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_UPDATE);
       }
       if (module->recommended_action & ModuleEnumerator::DISABLE) {
         if (!actions.empty())
           actions += separator;
         actions += l10n_util::GetStringUTF16(
             IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_DISABLE);
       }
-      string16 possible_resolution = actions.empty() ? ASCIIToWide("") :
+      string16 possible_resolution = actions.empty() ? base::ASCIIToWide("") :
           l10n_util::GetStringUTF16(IDS_CONFLICTS_CHECK_POSSIBLE_ACTIONS) +
-          ASCIIToWide(" ") +
+          base::ASCIIToWide(" ") +
           actions;
       data->SetString("possibleResolution", possible_resolution);
       data->SetString("help_url",
                       ConstructHelpCenterUrl(*module).spec().c_str());
     }
 
     list->Append(data);
   }
 
   lock->Release();
@@ skipping 62 matching lines @@
       content::NotificationService::NoDetails());
 }
 
 GURL EnumerateModulesModel::ConstructHelpCenterUrl(
     const ModuleEnumerator::Module& module) const {
   if (!(module.recommended_action & ModuleEnumerator::SEE_LINK))
     return GURL();
 
   // Construct the needed hashes.
   std::string filename, location, description, signer;
-  GenerateHash(WideToUTF8(module.name), &filename);
-  GenerateHash(WideToUTF8(module.location), &location);
-  GenerateHash(WideToUTF8(module.description), &description);
-  GenerateHash(WideToUTF8(module.digital_signer), &signer);
+  GenerateHash(base::WideToUTF8(module.name), &filename);
+  GenerateHash(base::WideToUTF8(module.location), &location);
+  GenerateHash(base::WideToUTF8(module.description), &description);
+  GenerateHash(base::WideToUTF8(module.digital_signer), &signer);
 
   string16 url = l10n_util::GetStringFUTF16(IDS_HELP_CENTER_VIEW_CONFLICTS,
       ASCIIToUTF16(filename), ASCIIToUTF16(location),
       ASCIIToUTF16(description), ASCIIToUTF16(signer));
   return GURL(UTF16ToUTF8(url));
 }