Remove GetSwitchValue() from chrome/* where easy.

chrome/installer/setup/setup_main.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 <string>
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
@@ skipping 213 matching lines @@
     return install_status;
 
   // For install the default location for chrome.packed.7z is in current
   // folder, so get that value first.
   std::wstring archive = file_util::GetDirectoryFromPath(cmd_line.program());
   file_util::AppendToPath(&archive,
                           std::wstring(installer::kChromeCompressedArchive));
 
   // If --install-archive is given, get the user specified value
   if (cmd_line.HasSwitch(installer_util::switches::kInstallArchive)) {
-    archive = cmd_line.GetSwitchValue(
+    archive = cmd_line.GetSwitchValueNative(
         installer_util::switches::kInstallArchive);
   }
   LOG(INFO) << "Archive found to install Chrome " << archive;
 
   // Create a temp folder where we will unpack Chrome archive. If it fails,
   // then we are doomed, so return immediately and no cleanup is required.
   FilePath temp_path;
   if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) {
     LOG(ERROR) << "Could not create temporary path.";
     InstallUtil::WriteInstallerResult(system_level,
@@ skipping 35 matching lines @@
         LOG(ERROR) << "Higher version is already installed.";
         install_status = installer_util::HIGHER_VERSION_EXISTS;
         InstallUtil::WriteInstallerResult(system_level, install_status,
                                           IDS_INSTALL_HIGHER_VERSION_BASE,
                                           NULL);
       } else {
         // We want to keep uncompressed archive (chrome.7z) that we get after
         // uncompressing and binary patching. Get the location for this file.
         std::wstring archive_to_copy(temp_path.ToWStringHack());
         file_util::AppendToPath(&archive_to_copy, installer::kChromeArchive);
-        std::wstring prefs_source_path = cmd_line.GetSwitchValue(
+        std::wstring prefs_source_path = cmd_line.GetSwitchValueNative(
             installer_util::switches::kInstallerData);
         install_status = installer::InstallOrUpdateChrome(
             cmd_line.program(), archive_to_copy, temp_path.ToWStringHack(),
             prefs_source_path, prefs, *installer_version, installed_version);
 
         int install_msg_base = IDS_INSTALL_FAILED_BASE;
         std::wstring chrome_exe;
         if (install_status == installer_util::SAME_VERSION_REPAIR_FAILED) {
             install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_BASE;
         } else if (install_status != installer_util::INSTALL_FAILED) {
@@ skipping 46 matching lines @@
                                system_level);
   }
 
   // Delete temporary files. These include install temporary directory
   // and master profile file if present. Note that we do not care about rollback
   // here and we schedule for deletion on reboot below if the deletes fail. As
   // such, we do not use DeleteTreeWorkItem.
   LOG(INFO) << "Deleting temporary directory " << temp_path.value();
   bool cleanup_success = file_util::Delete(temp_path, true);
   if (cmd_line.HasSwitch(installer_util::switches::kInstallerData)) {
-    std::wstring prefs_path = cmd_line.GetSwitchValue(
+    std::wstring prefs_path = cmd_line.GetSwitchValueNative(
         installer_util::switches::kInstallerData);
     cleanup_success = file_util::Delete(prefs_path, true) && cleanup_success;
   }
 
   // The above cleanup has been observed to fail on several users machines.
   // Specifically, it appears that the temp folder may be locked when we try
   // to delete it. This is Rather Bad in the case where we have failed updates
   // as we end up filling users' disks with large-ish temp files. To mitigate
   // this, if we fail to delete the temp folders, then schedule them for
   // deletion at next reboot.
   if (!cleanup_success) {
     ScheduleDirectoryForDeletion(temp_path.ToWStringHack().c_str());
     if (cmd_line.HasSwitch(installer_util::switches::kInstallerData)) {
-      std::wstring prefs_path = cmd_line.GetSwitchValue(
+      std::wstring prefs_path = cmd_line.GetSwitchValueNative(
           installer_util::switches::kInstallerData);
       ScheduleDirectoryForDeletion(prefs_path.c_str());
     }
   }
 
   dist->UpdateDiffInstallStatus(system_level, incremental_install,
                                 install_status);
   return install_status;
 }
 
@@ skipping 57 matching lines @@
   if (cmd_line.HasSwitch(installer_util::switches::kUpdateSetupExe)) {
     installer_util::InstallStatus status = installer_util::SETUP_PATCH_FAILED;
     // If --update-setup-exe command line option is given, we apply the given
     // patch to current exe, and store the resulting binary in the path
     // specified by --new-setup-exe. But we need to first unpack the file
     // given in --update-setup-exe.
     FilePath temp_path;
     if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) {
       LOG(ERROR) << "Could not create temporary path.";
     } else {
-      std::wstring setup_patch = cmd_line.GetSwitchValue(
+      std::wstring setup_patch = cmd_line.GetSwitchValueNative(
           installer_util::switches::kUpdateSetupExe);
       LOG(INFO) << "Opening archive " << setup_patch;
       std::wstring uncompressed_patch;
       if (LzmaUtil::UnPackArchive(setup_patch, temp_path.ToWStringHack(),
                                   &uncompressed_patch) == NO_ERROR) {
         std::wstring old_setup_exe = cmd_line.program();
-        std::wstring new_setup_exe = cmd_line.GetSwitchValue(
+        std::wstring new_setup_exe = cmd_line.GetSwitchValueNative(
             installer_util::switches::kNewSetupExe);
         if (!setup_util::ApplyDiffPatch(old_setup_exe, uncompressed_patch,
                                         new_setup_exe))
           status = installer_util::NEW_VERSION_UPDATED;
       }
     }
 
     exit_code = dist->GetInstallReturnCode(status);
     if (exit_code) {
       LOG(WARNING) << "setup.exe patching failed.";
       InstallUtil::WriteInstallerResult(system_install, status,
                                         IDS_SETUP_PATCH_FAILED_BASE, NULL);
     }
     file_util::Delete(temp_path, true);
     return true;
   } else if (cmd_line.HasSwitch(installer_util::switches::kShowEula)) {
     // Check if we need to show the EULA. If it is passed as a command line
     // then the dialog is shown and regardless of the outcome setup exits here.
     std::wstring inner_frame =
-        cmd_line.GetSwitchValue(installer_util::switches::kShowEula);
+        cmd_line.GetSwitchValueNative(installer_util::switches::kShowEula);
     exit_code = ShowEULADialog(inner_frame);
     if (installer_util::EULA_REJECTED != exit_code)
       GoogleUpdateSettings::SetEULAConsent(true);
     return true;
   } else if (cmd_line.HasSwitch(
       installer_util::switches::kRegisterChromeBrowser)) {
     // If --register-chrome-browser option is specified, register all
     // Chrome protocol/file associations as well as register it as a valid
     // browser for Start Menu->Internet shortcut. This option should only
     // be used when setup.exe is launched with admin rights. We do not
     // make any user specific changes in this option.
-    std::wstring chrome_exe(cmd_line.GetSwitchValue(
+    std::wstring chrome_exe(cmd_line.GetSwitchValueNative(
         installer_util::switches::kRegisterChromeBrowser));
     std::wstring suffix;
     if (cmd_line.HasSwitch(
         installer_util::switches::kRegisterChromeBrowserSuffix)) {
-      suffix = cmd_line.GetSwitchValue(
+      suffix = cmd_line.GetSwitchValueNative(
           installer_util::switches::kRegisterChromeBrowserSuffix);
     }
     exit_code = ShellUtil::RegisterChromeBrowser(chrome_exe, suffix, false);
     return true;
   } else if (cmd_line.HasSwitch(installer_util::switches::kRenameChromeExe)) {
     // If --rename-chrome-exe is specified, we want to rename the executables
     // and exit.
     exit_code = RenameChromeExecutables(system_install);
     return true;
   } else if (cmd_line.HasSwitch(
       installer_util::switches::kRemoveChromeRegistration)) {
     // This is almost reverse of --register-chrome-browser option above.
     // Here we delete Chrome browser registration. This option should only
     // be used when setup.exe is launched with admin rights. We do not
     // make any user specific changes in this option.
     std::wstring suffix;
     if (cmd_line.HasSwitch(
         installer_util::switches::kRegisterChromeBrowserSuffix)) {
-      suffix = cmd_line.GetSwitchValue(
+      suffix = cmd_line.GetSwitchValueNative(
           installer_util::switches::kRegisterChromeBrowserSuffix);
     }
     installer_util::InstallStatus tmp = installer_util::UNKNOWN_STATUS;
     installer_setup::DeleteChromeRegistrationKeys(HKEY_LOCAL_MACHINE,
                                                   suffix, tmp);
     exit_code = tmp;
     return true;
   } else if (cmd_line.HasSwitch(installer_util::switches::kInactiveUserToast)) {
     // Launch the inactive user toast experiment.
-    std::wstring flavor =
-        cmd_line.GetSwitchValue(installer_util::switches::kInactiveUserToast);
+    std::string flavor = cmd_line.GetSwitchValueASCII(
+        installer_util::switches::kInactiveUserToast);
     int flavor_int;
     base::StringToInt(flavor, &flavor_int);
     dist->InactiveUserToastExperiment(flavor_int,
         cmd_line.HasSwitch(installer_util::switches::kSystemLevelToast));
     return true;
   } else if (cmd_line.HasSwitch(installer_util::switches::kSystemLevelToast)) {
     // We started as system-level and have been re-launched as user level
     // to continue with the toast experiment.
     scoped_ptr<installer::Version>
         installed_version(InstallUtil::GetChromeVersion(system_install));
@@ skipping 205 matching lines @@
         parsed_command_line.HasSwitch(installer_util::switches::kUninstall))) {
     // Note that we allow the status installer_util::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is never
     // invoked directly by Google Update.
     return_code = dist->GetInstallReturnCode(install_status);
   }
 
   LOG(INFO) << "Installation complete, returning: " << return_code;
   return return_code;
 }