Make various string_util functions take StringPieces instead of char[].

chrome/installer/setup/install.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/installer/setup/install.h"
 
 #include <windows.h>
 #include <shlobj.h>
 #include <time.h>
 
@@ skipping 24 matching lines @@
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 
-using base::ASCIIToUTF16;
-using base::UTF16ToUTF8;
-using installer::InstallerState;
-using installer::InstallationState;
-using installer::Product;
 
 namespace {
 
 void LogShortcutOperation(ShellUtil::ShortcutLocation location,
                           BrowserDistribution* dist,
                           const ShellUtil::ShortcutProperties& properties,
                           ShellUtil::ShortcutOperation operation,
                           bool failed) {
   // ShellUtil::SHELL_SHORTCUT_UPDATE_EXISTING should not be used at install and
   // thus this method does not handle logging a message for it.
@@ skipping 11 matching lines @@
                                                                  "all-users ");
   switch (location) {
     case ShellUtil::SHORTCUT_LOCATION_DESKTOP:
       message.append("Desktop ");
       break;
     case ShellUtil::SHORTCUT_LOCATION_QUICK_LAUNCH:
       message.append("Quick Launch ");
       break;
     case ShellUtil::SHORTCUT_LOCATION_START_MENU_CHROME_DIR:
       message.append("Start menu/" +
-                     UTF16ToUTF8(dist->GetStartMenuShortcutSubfolder(
+                     base::UTF16ToUTF8(dist->GetStartMenuShortcutSubfolder(
                                      BrowserDistribution::SUBFOLDER_CHROME)) +
                       " ");
       break;
     case ShellUtil::SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR:
       message.append("Start menu/" +
-                     UTF16ToUTF8(dist->GetStartMenuShortcutSubfolder(
+                     base::UTF16ToUTF8(dist->GetStartMenuShortcutSubfolder(
                                      BrowserDistribution::SUBFOLDER_APPS)) +
                      " ");
       break;
     default:
       NOTREACHED();
   }
 
   message.push_back('"');
   if (properties.has_shortcut_name())
-    message.append(UTF16ToUTF8(properties.shortcut_name));
+    message.append(base::UTF16ToUTF8(properties.shortcut_name));
   else
-    message.append(UTF16ToUTF8(dist->GetDisplayName()));
+    message.append(base::UTF16ToUTF8(dist->GetDisplayName()));
   message.push_back('"');
 
   message.append(" shortcut to ");
-  message.append(UTF16ToUTF8(properties.target.value()));
+  message.append(base::UTF16ToUTF8(properties.target.value()));
   if (properties.has_arguments())
-    message.append(UTF16ToUTF8(properties.arguments));
+    message.append(base::UTF16ToUTF8(properties.arguments));
 
   if (properties.pin_to_taskbar &&
       base::win::GetVersion() >= base::win::VERSION_WIN7) {
     message.append(" and pinning to the taskbar.");
   } else {
     message.push_back('.');
   }
 
   if (failed)
     LOG(WARNING) << message;
@@ skipping 23 matching lines @@
       HKEY_LOCAL_MACHINE, reg_path));
 
   // if the operation fails we log the error but still continue
   if (!work_item.get()->Do())
     LOG(ERROR) << "Could not add Chrome to media player inclusion list.";
 }
 
 // Copy master_preferences file provided to installer, in the same folder
 // as chrome.exe so Chrome first run can find it. This function will be called
 // only on the first install of Chrome.
-void CopyPreferenceFileForFirstRun(const InstallerState& installer_state,
-                                   const base::FilePath& prefs_source_path) {
+void CopyPreferenceFileForFirstRun(
+    const installer::InstallerState& installer_state,
+    const base::FilePath& prefs_source_path) {
   base::FilePath prefs_dest_path(installer_state.target_path().AppendASCII(
       installer::kDefaultMasterPrefs));
   if (!base::CopyFile(prefs_source_path, prefs_dest_path)) {
     VLOG(1) << "Failed to copy master preferences from:"
             << prefs_source_path.value() << " gle: " << ::GetLastError();
   }
 }
 
 // This function installs a new version of Chrome to the specified location.
 //
 // setup_path: Path to the executable (setup.exe) as it will be copied
 //           to Chrome install folder after install is complete
 // archive_path: Path to the archive (chrome.7z) as it will be copied
 //               to Chrome install folder after install is complete
 // src_path: the path that contains a complete and unpacked Chrome package
 //           to be installed.
 // temp_path: the path of working directory used during installation. This path
 //            does not need to exist.
 // new_version: new Chrome version that needs to be installed
 // current_version: returns the current active version (if any)
 //
 // This function makes best effort to do installation in a transactional
 // manner. If failed it tries to rollback all changes on the file system
 // and registry. For example, if package exists before calling the
 // function, it rolls back all new file and directory changes under
 // package. If package does not exist before calling the function
 // (typical new install), the function creates package during install
 // and removes the whole directory during rollback.
 installer::InstallStatus InstallNewVersion(
-    const InstallationState& original_state,
-    const InstallerState& installer_state,
+    const installer::InstallationState& original_state,
+    const installer::InstallerState& installer_state,
     const base::FilePath& setup_path,
     const base::FilePath& archive_path,
     const base::FilePath& src_path,
     const base::FilePath& temp_path,
     const Version& new_version,
     scoped_ptr<Version>* current_version) {
   DCHECK(current_version);
 
   installer_state.UpdateStage(installer::BUILDING);
 
@@ skipping 57 matching lines @@
              << ", old version: " << (*current_version)->GetString();
 
   return installer::INSTALL_FAILED;
 }
 
 // Deletes the old "Uninstall Google Chrome" shortcut in the Start menu and, if
 // this is a system-level install, also deletes the old Default user Quick
 // Launch shortcut. Both of these were created prior to Chrome 24; in Chrome 24,
 // the uninstall shortcut was removed and the Default user Quick Launch shortcut
 // was replaced by per-user shortcuts created via Active Setup.
-void CleanupLegacyShortcuts(const InstallerState& installer_state,
+void CleanupLegacyShortcuts(const installer::InstallerState& installer_state,
                             BrowserDistribution* dist,
                             const base::FilePath& chrome_exe) {
   ShellUtil::ShellChange shortcut_level = installer_state.system_install() ?
       ShellUtil::SYSTEM_LEVEL : ShellUtil::CURRENT_USER;
   base::FilePath uninstall_shortcut_path;
   ShellUtil::GetShortcutPath(ShellUtil::SHORTCUT_LOCATION_START_MENU_CHROME_DIR,
                              dist, shortcut_level, &uninstall_shortcut_path);
   uninstall_shortcut_path = uninstall_shortcut_path.Append(
       dist->GetUninstallLinkName() + installer::kLnkExt);
   base::DeleteFile(uninstall_shortcut_path, false);
 
   if (installer_state.system_install()) {
     ShellUtil::RemoveShortcuts(
         ShellUtil::SHORTCUT_LOCATION_QUICK_LAUNCH, dist,
         ShellUtil::SYSTEM_LEVEL, chrome_exe);
   }
 }
 
 // Returns the appropriate shortcut operations for App Launcher,
 // based on state of installation and master_preferences.
 installer::InstallShortcutOperation GetAppLauncherShortcutOperation(
-    const InstallationState& original_state,
-    const InstallerState& installer_state) {
+    const installer::InstallationState& original_state,
+    const installer::InstallerState& installer_state) {
   const installer::ProductState* original_app_host_state =
       original_state.GetProductState(installer_state.system_install(),
                                      BrowserDistribution::CHROME_APP_HOST);
   bool app_launcher_exists = original_app_host_state &&
       original_app_host_state->uninstall_command()
           .HasSwitch(installer::switches::kChromeAppLauncher);
   if (!app_launcher_exists)
     return installer::INSTALL_SHORTCUT_CREATE_ALL;
 
   return installer::INSTALL_SHORTCUT_REPLACE_EXISTING;
 }
 
 }  // end namespace
 
 namespace installer {
 
 void EscapeXmlAttributeValueInSingleQuotes(base::string16* att_value) {
-  base::ReplaceChars(*att_value, L"&", L"&amp;", att_value);
-  base::ReplaceChars(*att_value, L"'", L"&apos;", att_value);
-  base::ReplaceChars(*att_value, L"<", L"&lt;", att_value);
+  base::ReplaceChars(*att_value, base::ASCIIToUTF16("&"),
+                     base::ASCIIToUTF16("&amp;"), att_value);
+  base::ReplaceChars(*att_value, base::ASCIIToUTF16("'"),
+                     base::ASCIIToUTF16("&apos;"), att_value);
+  base::ReplaceChars(*att_value, base::ASCIIToUTF16("<"),
+                     base::ASCIIToUTF16("&lt;"), att_value);
 }
 
 bool CreateVisualElementsManifest(const base::FilePath& src_path,
                                   const Version& version) {
   // Construct the relative path to the versioned VisualElements directory.
-  base::string16 elements_dir(ASCIIToUTF16(version.GetString()));
+  base::string16 elements_dir(base::ASCIIToUTF16(version.GetString()));
   elements_dir.push_back(base::FilePath::kSeparators[0]);
   elements_dir.append(installer::kVisualElements);
 
   // Some distributions of Chromium may not include visual elements. Only
   // proceed if this distribution does.
   if (!base::PathExists(src_path.Append(elements_dir))) {
     VLOG(1) << "No visual elements found, not writing "
             << installer::kVisualElementsManifest << " to " << src_path.value();
     return true;
   } else {
     // A printf_p-style format string for generating the visual elements
     // manifest. Required arguments, in order, are:
     //   - Localized display name for the product.
     //   - Relative path to the VisualElements directory.
     static const char kManifestTemplate[] =
         "<Application>\r\n"
         "  <VisualElements\r\n"
         "      DisplayName='%1$ls'\r\n"
         "      Logo='%2$ls\\Logo.png'\r\n"
         "      SmallLogo='%2$ls\\SmallLogo.png'\r\n"
         "      ForegroundText='light'\r\n"
         "      BackgroundColor='#323232'>\r\n"
         "    <DefaultTile ShowName='allLogos'/>\r\n"
         "    <SplashScreen Image='%2$ls\\splash-620x300.png'/>\r\n"
         "  </VisualElements>\r\n"
         "</Application>";
 
-    const base::string16 manifest_template(ASCIIToUTF16(kManifestTemplate));
+    const base::string16 manifest_template(
+        base::ASCIIToUTF16(kManifestTemplate));
 
     BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BROWSER);
     // TODO(grt): http://crbug.com/75152 Write a reference to a localized
     // resource for |display_name|.
     base::string16 display_name(dist->GetDisplayName());
     EscapeXmlAttributeValueInSingleQuotes(&display_name);
 
     // Fill the manifest with the desired values.
     base::string16 manifest16(base::StringPrintf(
         manifest_template.c_str(), display_name.c_str(), elements_dir.c_str()));
 
     // Write the manifest to |src_path|.
-    const std::string manifest(UTF16ToUTF8(manifest16));
+    const std::string manifest(base::UTF16ToUTF8(manifest16));
     int size = base::checked_cast<int>(manifest.size());
     if (base::WriteFile(
         src_path.Append(installer::kVisualElementsManifest),
             manifest.c_str(), size) == size) {
       VLOG(1) << "Successfully wrote " << installer::kVisualElementsManifest
               << " to " << src_path.value();
       return true;
     } else {
       PLOG(ERROR) << "Error writing " << installer::kVisualElementsManifest
                   << " to " << src_path.value();
       return false;
     }
   }
 }
 
 void CreateOrUpdateShortcuts(
     const base::FilePath& target,
-    const Product& product,
+    const installer::Product& product,
     const MasterPreferences& prefs,
     InstallShortcutLevel install_level,
     InstallShortcutOperation install_operation) {
   bool do_not_create_any_shortcuts = false;
   prefs.GetBool(master_preferences::kDoNotCreateAnyShortcuts,
                 &do_not_create_any_shortcuts);
   if (do_not_create_any_shortcuts)
     return;
 
   // Extract shortcut preferences from |prefs|.
@@ skipping 83 matching lines @@
       (shortcut_operation == ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS ||
        shortcut_operation ==
            ShellUtil::SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL)) {
     start_menu_properties.set_pin_to_taskbar(true);
   }
   ExecuteAndLogShortcutOperation(
       ShellUtil::SHORTCUT_LOCATION_START_MENU_CHROME_DIR, dist,
       start_menu_properties, shortcut_operation);
 }
 
-void RegisterChromeOnMachine(const InstallerState& installer_state,
-                             const Product& product,
+void RegisterChromeOnMachine(const installer::InstallerState& installer_state,
+                             const installer::Product& product,
                              bool make_chrome_default) {
   DCHECK(product.is_chrome());
 
   // Try to add Chrome to Media Player shim inclusion list. We don't do any
   // error checking here because this operation will fail if user doesn't
   // have admin rights and we want to ignore the error.
   AddChromeToMediaPlayerList();
 
   // Make Chrome the default browser if desired when possible. Otherwise, only
   // register it with Windows.
   BrowserDistribution* dist = product.distribution();
   const base::string16 chrome_exe(
       installer_state.target_path().Append(installer::kChromeExe).value());
   VLOG(1) << "Registering Chrome as browser: " << chrome_exe;
   if (make_chrome_default && ShellUtil::CanMakeChromeDefaultUnattended()) {
     int level = ShellUtil::CURRENT_USER;
     if (installer_state.system_install())
       level = level | ShellUtil::SYSTEM_LEVEL;
     ShellUtil::MakeChromeDefault(dist, level, chrome_exe, true);
   } else {
     ShellUtil::RegisterChromeBrowser(dist, chrome_exe, base::string16(), false);
   }
 }
 
 InstallStatus InstallOrUpdateProduct(
-    const InstallationState& original_state,
-    const InstallerState& installer_state,
+    const installer::InstallationState& original_state,
+    const installer::InstallerState& installer_state,
     const base::FilePath& setup_path,
     const base::FilePath& archive_path,
     const base::FilePath& install_temp_path,
     const base::FilePath& src_path,
     const base::FilePath& prefs_path,
     const MasterPreferences& prefs,
     const Version& new_version) {
   DCHECK(!installer_state.products().empty());
 
   // TODO(robertshield): Removing the pending on-reboot moves should be done
@@ skipping 24 matching lines @@
     // installed and for the binaries in case of multi-install.
     installer_state.UpdateChannels();
 
     installer_state.UpdateStage(installer::COPYING_PREFERENCES_FILE);
 
     if (result == FIRST_INSTALL_SUCCESS && !prefs_path.empty())
       CopyPreferenceFileForFirstRun(installer_state, prefs_path);
 
     installer_state.UpdateStage(installer::CREATING_SHORTCUTS);
 
-    const Product* app_launcher_product =
+    const installer::Product* app_launcher_product =
         installer_state.FindProduct(BrowserDistribution::CHROME_APP_HOST);
     // Creates shortcuts for App Launcher.
     if (app_launcher_product) {
       // TODO(huangs): Remove this check once we have system-level App Host.
       DCHECK(!installer_state.system_install());
       const base::FilePath app_host_exe(
           installer_state.target_path().Append(kChromeAppHostExe));
       InstallShortcutOperation app_launcher_shortcut_operation =
           GetAppLauncherShortcutOperation(original_state, installer_state);
 
       // Always install per-user shortcuts for App Launcher.
       CreateOrUpdateShortcuts(app_host_exe, *app_launcher_product, prefs,
                               CURRENT_USER, app_launcher_shortcut_operation);
     }
 
-    const Product* chrome_product =
+    const installer::Product* chrome_product =
         installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER);
     // Creates shortcuts for Chrome.
     if (chrome_product) {
       BrowserDistribution* chrome_dist = chrome_product->distribution();
       const base::FilePath chrome_exe(
           installer_state.target_path().Append(kChromeExe));
       CleanupLegacyShortcuts(installer_state, chrome_dist, chrome_exe);
 
       // Install per-user shortcuts on user-level installs and all-users
       // shortcuts on system-level installs. Note that Active Setup will take
@@ skipping 44 matching lines @@
       if (result == FIRST_INSTALL_SUCCESS) {
         installer_state.UpdateStage(installer::CONFIGURE_AUTO_LAUNCH);
 
         // Add auto-launch key if specified in master_preferences.
         bool auto_launch_chrome = false;
         prefs.GetBool(
             installer::master_preferences::kAutoLaunchChrome,
             &auto_launch_chrome);
         if (auto_launch_chrome) {
           auto_launch_util::EnableForegroundStartAtLogin(
-              ASCIIToUTF16(chrome::kInitialProfile),
+              base::ASCIIToUTF16(chrome::kInitialProfile),
               installer_state.target_path());
         }
       }
     }
 
     installer_state.UpdateStage(installer::REMOVING_OLD_VERSIONS);
 
     installer_state.RemoveOldVersionDirectories(
         new_version,
         existing_version.get(),
         install_temp_path);
   }
 
   return result;
 }
 
-void HandleOsUpgradeForBrowser(const InstallerState& installer_state,
-                               const Product& chrome) {
+void HandleOsUpgradeForBrowser(const installer::InstallerState& installer_state,
+                               const installer::Product& chrome) {
   DCHECK(chrome.is_chrome());
   // Upon upgrading to Windows 8, we need to fix Chrome shortcuts and register
   // Chrome, so that Metro Chrome would work if Chrome is the default browser.
   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
     VLOG(1) << "Updating and registering shortcuts.";
     // Read master_preferences copied beside chrome.exe at install.
     MasterPreferences prefs(
         installer_state.target_path().AppendASCII(kDefaultMasterPrefs));
 
     // Unfortunately, if this is a system-level install, we can't update the
     // shortcuts of each individual user (this only matters if this is an OS
     // upgrade from XP/Vista to Win7+ as some properties are only set on
     // shortcuts as of Win7).
     // At least attempt to update potentially existing all-users shortcuts.
     InstallShortcutLevel level = installer_state.system_install() ?
         ALL_USERS : CURRENT_USER;
     base::FilePath chrome_exe(installer_state.target_path().Append(kChromeExe));
     CreateOrUpdateShortcuts(
         chrome_exe, chrome, prefs, level, INSTALL_SHORTCUT_REPLACE_EXISTING);
     RegisterChromeOnMachine(installer_state, chrome, false);
   }
 }
 
 // NOTE: Should the work done here, on Active Setup, change: kActiveSetupVersion
 // in install_worker.cc needs to be increased for Active Setup to invoke this
 // again for all users of this install.
 void HandleActiveSetupForBrowser(const base::FilePath& installation_root,
-                                 const Product& chrome,
+                                 const installer::Product& chrome,
                                  bool force) {
   DCHECK(chrome.is_chrome());
   // Only create shortcuts on Active Setup if the first run sentinel is not
   // present for this user (as some shortcuts used to be installed on first
   // run and this could otherwise re-install shortcuts for users that have
   // already deleted them in the past).
   // Decide whether to create the shortcuts or simply replace existing
   // shortcuts; if the decision is to create them, only shortcuts whose matching
   // all-users shortcut isn't present on the system will be created.
   InstallShortcutOperation install_operation =
@@ skipping 13 matching lines @@
   if (app_host_path.empty())
     return false;
 
   CommandLine cmd(app_host_path);
   cmd.AppendSwitchASCII(::switches::kInstallFromWebstore, app_code);
   VLOG(1) << "App install command: " << cmd.GetCommandLineString();
   return base::LaunchProcess(cmd, base::LaunchOptions(), NULL);
 }
 
 }  // namespace installer