Add utf_string_conversions to base namespace.

chrome/installer/setup/install_worker.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.
 //
 // This file contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <oaidl.h>
@@ skipping 227 matching lines @@
   DCHECK(command_key);
   DCHECK(app);
   DCHECK(command_with_parameter);
   DCHECK(work_item_list);
 
   string16 full_cmd_key(GetRegCommandKey(product.distribution(), command_key));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     work_item_list->AddDeleteRegKeyWorkItem(
         installer_state.root_key(), full_cmd_key)->set_log_message(
-            "removing " + WideToASCII(command_key) + " command");
+            "removing " + base::WideToASCII(command_key) + " command");
   } else {
     CommandLine cmd_line(installer_state.target_path().Append(app));
     cmd_line.AppendSwitchASCII(command_with_parameter, "%1");
 
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_sends_pings(true);
     cmd.set_is_web_accessible(true);
     cmd.set_is_run_as_user(true);
     cmd.AddWorkItems(installer_state.root_key(), full_cmd_key, work_item_list);
   }
@@ skipping 484 matching lines @@
                                          L"NoModify", static_cast<DWORD>(1),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"NoRepair", static_cast<DWORD>(1),
                                          true);
 
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"Publisher",
                                          browser_dist->GetPublisherName(),
                                          true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-                                         L"Version",
-                                         ASCIIToWide(new_version.GetString()),
-                                         true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-                                         L"DisplayVersion",
-                                         ASCIIToWide(new_version.GetString()),
-                                         true);
+    install_list->AddSetRegValueWorkItem(
+        reg_root, uninstall_reg,
+        L"Version",
+        base::ASCIIToWide(new_version.GetString()),
+        true);
+    install_list->AddSetRegValueWorkItem(
+        reg_root, uninstall_reg,
+        L"DisplayVersion",
+        base::ASCIIToWide(new_version.GetString()),
+        true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"InstallDate",
                                          InstallUtil::GetCurrentDate(),
                                          false);
 
     const std::vector<uint16>& version_components = new_version.components();
     if (version_components.size() == 4) {
       // Our version should be in major.minor.build.rev.
       install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
           L"VersionMajor", static_cast<DWORD>(version_components[2]), true);
@@ skipping 28 matching lines @@
     // exception: what Chrome calls "en-us", Omaha calls "en".  sigh.
     string16 language(GetCurrentTranslation());
     if (LowerCaseEqualsASCII(language, "en-us"))
       language.resize(2);
     list->AddSetRegValueWorkItem(root, version_key,
                                  google_update::kRegLangField, language,
                                  false);  // do not overwrite language
   }
   list->AddSetRegValueWorkItem(root, version_key,
                                google_update::kRegVersionField,
-                               ASCIIToWide(new_version.GetString()),
+                               base::ASCIIToWide(new_version.GetString()),
                                true);  // overwrite version
 }
 
 // Mirror oeminstall the first time anything is installed multi.  There is no
 // need to update the value on future install/update runs since this value never
 // changes.  Note that the value is removed by Google Update after EULA
 // acceptance is processed.
 void AddOemInstallWorkItems(const InstallationState& original_state,
                             const InstallerState& installer_state,
                             WorkItemList* install_list) {
@@ skipping 243 matching lines @@
       rename.AppendSwitch(switches::kVerboseLogging);
 
     string16 version_key;
     for (size_t i = 0; i < products.size(); ++i) {
       BrowserDistribution* dist = products[i]->distribution();
       version_key = dist->GetVersionKey();
 
       if (current_version) {
         in_use_update_work_items->AddSetRegValueWorkItem(root, version_key,
             google_update::kRegOldVersionField,
-            ASCIIToWide(current_version->GetString()), true);
+            base::ASCIIToWide(current_version->GetString()), true);
       }
       if (critical_version.IsValid()) {
         in_use_update_work_items->AddSetRegValueWorkItem(root, version_key,
             google_update::kRegCriticalVersionField,
-            ASCIIToWide(critical_version.GetString()), true);
+            base::ASCIIToWide(critical_version.GetString()), true);
       } else {
         in_use_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
             google_update::kRegCriticalVersionField);
       }
 
       // Adding this registry entry for all products (but the binaries) is
       // overkill. However, as it stands, we don't have a way to know which
       // product will check the key and run the command, so we add it for all.
       // The first to run it will perform the operation and clean up the other
       // values.
@@ skipping 586 matching lines @@
                        BrowserDistribution::GetSpecificDistribution(
                            BrowserDistribution::CHROME_BINARIES),
                        kCmdQuickEnableCf));
 
   if (will_have_chrome_frame) {
     // Chrome Frame is (to be) installed. Unconditionally remove the Quick
     // Enable command from the binaries. We do this even if multi-install Chrome
     // isn't installed since we don't want them left behind in any case.
     work_item_list->AddDeleteRegKeyWorkItem(
         installer_state.root_key(), cmd_key)->set_log_message(
-            "removing " + WideToASCII(kCmdQuickEnableCf) + " command");
+            "removing " + base::WideToASCII(kCmdQuickEnableCf) + " command");
 
   } else if (will_have_chrome_binaries) {
     // Chrome Frame isn't (to be) installed while some other multi-install
     // product is (to be) installed. Add the Quick Enable command to
     // the binaries.
     CommandLine cmd_line(GetGenericQuickEnableCommand(installer_state,
                                                       machine_state,
                                                       setup_path,
                                                       new_version));
     // kMultiInstall and kVerboseLogging were processed above.
     cmd_line.AppendSwitch(switches::kChromeFrameQuickEnable);
     if (installer_state.system_install())
       cmd_line.AppendSwitch(switches::kSystemLevel);
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_sends_pings(true);
     cmd.set_is_web_accessible(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, work_item_list);
   }
 }
 
 }  // namespace installer