CommandLine: remove wstring-based program() accessor

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 <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include <string>
@@ skipping 69 matching lines @@
       LOG(ERROR) << "Can not use differential update when Chrome is not "
                  << "installed on the system.";
       return installer_util::CHROME_NOT_INSTALLED;
     }
     std::wstring existing_archive =
         installer::GetChromeInstallPath(system_install);
     file_util::AppendToPath(&existing_archive,
                             installed_version->GetString());
     file_util::AppendToPath(&existing_archive, installer_util::kInstallerDir);
     file_util::AppendToPath(&existing_archive, installer::kChromeArchive);
-    if (int i = setup_util::ApplyDiffPatch(existing_archive, unpacked_file,
-                                           uncompressed_archive)) {
+    if (int i = setup_util::ApplyDiffPatch(FilePath(existing_archive),
+                                           FilePath(unpacked_file),
+                                           FilePath(uncompressed_archive))) {
       LOG(ERROR) << "Binary patching failed with error " << i;
       return i;
     }
   }
 
   // Unpack the uncompressed archive.
   return LzmaUtil::UnPackArchive(uncompressed_archive, path, &unpacked_file);
 }
 
 
@@ skipping 118 matching lines @@
   bool system_level = false;
   installer_util::GetDistroBooleanPreference(prefs,
       installer_util::master_preferences::kSystemLevel, &system_level);
   installer_util::InstallStatus install_status = installer_util::UNKNOWN_STATUS;
   if (!CheckPreInstallConditions(installed_version,
                                  system_level, install_status))
     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));
+  FilePath archive =

[viettrungluu, 2010/10/14 19:51:27]

Probably the way to break this line (to be consistent with other line breaks in
this file) is:

FilePath archive = cmd_line.GetProgram().DirName().Append(
    installer::kChromeCompressedArchive);

+      cmd_line.GetProgram().DirName()
+      .Append(installer::kChromeCompressedArchive);
 
   // If --install-archive is given, get the user specified value
   if (cmd_line.HasSwitch(installer_util::switches::kInstallArchive)) {
-    archive = cmd_line.GetSwitchValueNative(
+    archive = cmd_line.GetSwitchValuePath(
         installer_util::switches::kInstallArchive);
   }
-  LOG(INFO) << "Archive found to install Chrome " << archive;
+  LOG(INFO) << "Archive found to install Chrome " << archive.value();
 
   // 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,
                                       installer_util::TEMP_DIR_FAILED,
                                       IDS_INSTALL_TEMP_DIR_FAILED_BASE,
                                       NULL);
     return installer_util::TEMP_DIR_FAILED;
   }
   LOG(INFO) << "created path " << temp_path.value();
 
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring unpack_path(temp_path.ToWStringHack());
   file_util::AppendToPath(&unpack_path,
                           std::wstring(installer::kInstallSourceDir));
   bool incremental_install = false;
-  if (UnPackArchive(archive, system_level, installed_version,
+  if (UnPackArchive(archive.value(), system_level, installed_version,
                     temp_path.ToWStringHack(), unpack_path,
                     incremental_install)) {
     install_status = installer_util::UNCOMPRESSION_FAILED;
     InstallUtil::WriteInstallerResult(system_level, install_status,
                                       IDS_INSTALL_UNCOMPRESSION_FAILED_BASE,
                                       NULL);
   } else {
     LOG(INFO) << "unpacked to " << unpack_path;
     std::wstring src_path(unpack_path);
     file_util::AppendToPath(&src_path,
         std::wstring(installer::kInstallSourceChromeDir));
     scoped_ptr<installer::Version>
-        installer_version(setup_util::GetVersionFromDir(src_path));
+        installer_version(setup_util::GetVersionFromDir(FilePath(src_path)));
     if (!installer_version.get()) {
       LOG(ERROR) << "Did not find any valid version in installer.";
       install_status = installer_util::INVALID_ARCHIVE;
       InstallUtil::WriteInstallerResult(system_level, install_status,
                                         IDS_INSTALL_INVALID_ARCHIVE_BASE, NULL);
     } else {
       LOG(INFO) << "version to install: " << installer_version->GetString();
       if (installed_version &&
           installed_version->IsHigherThan(installer_version.get())) {
         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);
+        FilePath archive_to_copy = temp_path.Append(installer::kChromeArchive);
         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(),
+            cmd_line.GetProgram().value(), archive_to_copy.value(),
+            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) {
           chrome_exe = installer::GetChromeInstallPath(system_level);
           if (chrome_exe.empty()) {
             // If we failed to construct install path, it means the OS call to
@@ skipping 85 matching lines @@
     LOG(ERROR) << "No Chrome installation found for uninstall.";
     InstallUtil::WriteInstallerResult(system_install,
                                       installer_util::CHROME_NOT_INSTALLED,
                                       IDS_UNINSTALL_FAILED_BASE, NULL);
     return installer_util::CHROME_NOT_INSTALLED;
   }
 
   bool remove_all = !cmd_line.HasSwitch(
       installer_util::switches::kDoNotRemoveSharedItems);
 
-  return installer_setup::UninstallChrome(cmd_line.program(), system_install,
+  return installer_setup::UninstallChrome(cmd_line.GetProgram().value(),
+                                          system_install,
                                           remove_all, force,
                                           cmd_line, cmd_params);
 }
 
 installer_util::InstallStatus ShowEULADialog(const std::wstring& inner_frame) {
   LOG(INFO) << "About to show EULA";
   std::wstring eula_path = installer_util::GetLocalizedEulaResource();
   if (eula_path.empty()) {
     LOG(ERROR) << "No EULA path available";
     return installer_util::EULA_REJECTED;
@@ skipping 35 matching lines @@
     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.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.GetSwitchValueNative(
+        FilePath old_setup_exe = cmd_line.GetProgram();
+        FilePath new_setup_exe = cmd_line.GetSwitchValuePath(
             installer_util::switches::kNewSetupExe);
-        if (!setup_util::ApplyDiffPatch(old_setup_exe, uncompressed_patch,
+        if (!setup_util::ApplyDiffPatch(old_setup_exe,
+                                        FilePath(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);
@@ skipping 198 matching lines @@
   }
 
   int exit_code = 0;
   if (HandleNonInstallCmdLineOptions(parsed_command_line, system_install,
                                      exit_code))
     return exit_code;
 
   if (system_install && !IsUserAnAdmin()) {
     if (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA &&
         !parsed_command_line.HasSwitch(installer_util::switches::kRunAsAdmin)) {
-      std::wstring exe = parsed_command_line.program();
+      std::wstring exe = parsed_command_line.GetProgram().value();
       std::wstring params(command_line);
       // Append --run-as-admin flag to let the new instance of setup.exe know
       // that we already tried to launch ourselves as admin.
       params.append(L" --");
       params.append(installer_util::switches::kRunAsAdmin);
       DWORD exit_code = installer_util::UNKNOWN_STATUS;
       InstallUtil::ExecuteExeAsAdmin(exe, params, &exit_code);
       return exit_code;
     } else {
       LOG(ERROR) << "Non admin user can not install system level Chrome.";
@@ skipping 51 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;
 }