diff options
Diffstat (limited to 'chrome/installer/setup')
| -rw-r--r-- | chrome/installer/setup/install.cc | 226 | ||||
| -rw-r--r-- | chrome/installer/setup/install.h | 15 | ||||
| -rw-r--r-- | chrome/installer/setup/setup_main.cc | 93 | ||||
| -rw-r--r-- | chrome/installer/setup/uninstall.cc | 65 | ||||
| -rw-r--r-- | chrome/installer/setup/uninstall.h | 12 |
5 files changed, 200 insertions, 211 deletions
diff --git a/chrome/installer/setup/install.cc b/chrome/installer/setup/install.cc index 143f5ba..12273f9 100644 --- a/chrome/installer/setup/install.cc +++ b/chrome/installer/setup/install.cc @@ -37,13 +37,6 @@ COMPILE_ASSERT(kNumDllsToRegister > 0, namespace { -std::wstring AppendPath(const std::wstring& parent_path, - const std::wstring& path) { - std::wstring new_path(parent_path); - file_util::AppendToPath(&new_path, path); - return new_path; -} - void AddChromeToMediaPlayerList() { std::wstring reg_path(installer::kMediaPlayerRegPath); // registry paths can also be appended like file system path @@ -57,24 +50,19 @@ void AddChromeToMediaPlayerList() { LOG(ERROR) << "Could not add Chrome to media player inclusion list."; } -void AddInstallerCopyTasks(const std::wstring& exe_path, - const std::wstring& archive_path, - const std::wstring& temp_path, - const std::wstring& install_path, +void AddInstallerCopyTasks(const FilePath& exe_path, + const FilePath& archive_path, + const FilePath& temp_path, + const FilePath& install_path, const std::wstring& new_version, WorkItemList* install_list, bool system_level) { - std::wstring installer_dir(installer::GetInstallerPathUnderChrome( - install_path, new_version)); - install_list->AddCreateDirWorkItem( - FilePath::FromWStringHack(installer_dir)); - - std::wstring exe_dst(installer_dir); - std::wstring archive_dst(installer_dir); - file_util::AppendToPath(&exe_dst, - file_util::GetFilenameFromPath(exe_path)); - file_util::AppendToPath(&archive_dst, - file_util::GetFilenameFromPath(archive_path)); + FilePath installer_dir(installer::GetInstallerPathUnderChrome(install_path, + new_version)); + install_list->AddCreateDirWorkItem(installer_dir); + + FilePath exe_dst(installer_dir.Append(exe_path.BaseName())); + FilePath archive_dst(installer_dir.Append(archive_path.BaseName())); install_list->AddCopyTreeWorkItem(exe_path, exe_dst, temp_path, WorkItem::ALWAYS); @@ -117,16 +105,15 @@ void AppendUninstallCommandLineFlags(std::wstring* uninstall_cmd_line, // This method adds work items to create (or update) Chrome uninstall entry in // Control Panel->Add/Remove Programs list. void AddUninstallShortcutWorkItems(HKEY reg_root, - const std::wstring& exe_path, - const std::wstring& install_path, + const FilePath& exe_path, + const FilePath& install_path, const std::wstring& product_name, const std::wstring& new_version, WorkItemList* install_list) { std::wstring uninstall_cmd(L"\""); uninstall_cmd.append(installer::GetInstallerPathUnderChrome(install_path, - new_version)); - file_util::AppendToPath(&uninstall_cmd, - file_util::GetFilenameFromPath(exe_path)); + new_version).value()); + file_util::AppendToPath(&uninstall_cmd, exe_path.BaseName().value()); uninstall_cmd.append(L"\""); AppendUninstallCommandLineFlags(&uninstall_cmd, @@ -144,11 +131,12 @@ void AddUninstallShortcutWorkItems(HKEY reg_root, uninstall_cmd, true); install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg, - L"InstallLocation", install_path, true); + L"InstallLocation", + install_path.value(), true); // DisplayIcon, NoModify and NoRepair - std::wstring chrome_icon = AppendPath(install_path, - installer_util::kChromeExe); + std::wstring chrome_icon = install_path.Append( + installer_util::kChromeExe).value(); ShellUtil::GetChromeIcon(chrome_icon); install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg, L"DisplayIcon", chrome_icon, true); @@ -180,14 +168,11 @@ void AddUninstallShortcutWorkItems(HKEY reg_root, // as chrome.exe so Chrome first run can find it. This function will be called // only on the first install of Chrome. void CopyPreferenceFileForFirstRun(bool system_level, - const std::wstring& prefs_source_path) { - FilePath prefs_dest_path = FilePath::FromWStringHack( - installer::GetChromeInstallPath(system_level)); + const FilePath& prefs_source_path) { + FilePath prefs_dest_path = installer::GetChromeInstallPath(system_level); prefs_dest_path = prefs_dest_path.Append(installer_util::kDefaultMasterPrefs); - if (!file_util::CopyFile(FilePath::FromWStringHack(prefs_source_path), - prefs_dest_path)) { + if (!file_util::CopyFile(prefs_source_path, prefs_dest_path)) LOG(INFO) << "Failed to copy master preferences."; - } } // This method creates Chrome shortcuts in Start->Programs for all users or @@ -204,8 +189,8 @@ void CopyPreferenceFileForFirstRun(bool system_level, // // If the shortcuts do not exist, the function does not recreate them during // update. -bool CreateOrUpdateChromeShortcuts(const std::wstring& exe_path, - const std::wstring& install_path, +bool CreateOrUpdateChromeShortcuts(const FilePath& exe_path, + const FilePath& install_path, const std::wstring& new_version, installer_util::InstallStatus install_status, bool system_install, @@ -233,53 +218,52 @@ bool CreateOrUpdateChromeShortcuts(const std::wstring& exe_path, // shortcuts since our install. So on updates we only update if shortcut // already exists) bool ret = true; - FilePath chrome_link(shortcut_path); // Chrome link (launches Chrome) - chrome_link = chrome_link.Append(product_name + L".lnk"); - std::wstring chrome_exe(install_path); // Chrome link target - file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe); + // Chrome link (launches Chrome). + FilePath chrome_link(shortcut_path.Append(product_name + L".lnk")); + // Chrome link target. + FilePath chrome_exe(install_path.Append(installer_util::kChromeExe)); if ((install_status == installer_util::FIRST_INSTALL_SUCCESS) || (install_status == installer_util::INSTALL_REPAIRED)) { if (!file_util::PathExists(shortcut_path)) - file_util::CreateDirectoryW(shortcut_path); + file_util::CreateDirectory(shortcut_path); - LOG(INFO) << "Creating shortcut to " << chrome_exe << " at " + LOG(INFO) << "Creating shortcut to " << chrome_exe.value() << " at " << chrome_link.value(); - ret = ret && ShellUtil::UpdateChromeShortcut(chrome_exe, + ret = ret && ShellUtil::UpdateChromeShortcut(chrome_exe.value(), chrome_link.value(), product_desc, true); } else if (file_util::PathExists(chrome_link)) { LOG(INFO) << "Updating shortcut at " << chrome_link.value() - << " to point to " << chrome_exe; - ret = ret && ShellUtil::UpdateChromeShortcut(chrome_exe, + << " to point to " << chrome_exe.value(); + ret = ret && ShellUtil::UpdateChromeShortcut(chrome_exe.value(), chrome_link.value(), product_desc, false); } - // Create/update uninstall link - FilePath uninstall_link(shortcut_path); // Uninstall Chrome link - uninstall_link = uninstall_link.Append( - dist->GetUninstallLinkName() + L".lnk"); + // Create/update uninstall link. + FilePath uninstall_link(shortcut_path.Append( + dist->GetUninstallLinkName() + L".lnk")); if ((install_status == installer_util::FIRST_INSTALL_SUCCESS) || (install_status == installer_util::INSTALL_REPAIRED) || (file_util::PathExists(uninstall_link))) { if (!file_util::PathExists(shortcut_path)) - file_util::CreateDirectoryW(shortcut_path); - std::wstring setup_exe(installer::GetInstallerPathUnderChrome(install_path, - new_version)); - file_util::AppendToPath(&setup_exe, - file_util::GetFilenameFromPath(exe_path)); + file_util::CreateDirectory(shortcut_path); + FilePath setup_exe(installer::GetInstallerPathUnderChrome(install_path, + new_version)); + setup_exe = setup_exe.Append(exe_path.BaseName()); std::wstring arguments; AppendUninstallCommandLineFlags(&arguments, system_install); LOG(INFO) << "Creating/updating uninstall link at " << uninstall_link.value(); - ret = ret && file_util::CreateShortcutLink(setup_exe.c_str(), + ret = ret && file_util::CreateShortcutLink(setup_exe.value().c_str(), uninstall_link.value().c_str(), NULL, arguments.c_str(), - NULL, setup_exe.c_str(), 0, + NULL, setup_exe.value().c_str(), + 0, NULL); } @@ -287,16 +271,16 @@ bool CreateOrUpdateChromeShortcuts(const std::wstring& exe_path, // is specified we want to create them, otherwise we update them only if // they exist. if (system_install) { - ret = ret && ShellUtil::CreateChromeDesktopShortcut(chrome_exe, + ret = ret && ShellUtil::CreateChromeDesktopShortcut(chrome_exe.value(), product_desc, ShellUtil::SYSTEM_LEVEL, alt_shortcut, create_all_shortcut); - ret = ret && ShellUtil::CreateChromeQuickLaunchShortcut(chrome_exe, + ret = ret && ShellUtil::CreateChromeQuickLaunchShortcut(chrome_exe.value(), ShellUtil::CURRENT_USER | ShellUtil::SYSTEM_LEVEL, create_all_shortcut); } else { - ret = ret && ShellUtil::CreateChromeDesktopShortcut(chrome_exe, + ret = ret && ShellUtil::CreateChromeDesktopShortcut(chrome_exe.value(), product_desc, ShellUtil::CURRENT_USER, alt_shortcut, create_all_shortcut); - ret = ret && ShellUtil::CreateChromeQuickLaunchShortcut(chrome_exe, + ret = ret && ShellUtil::CreateChromeQuickLaunchShortcut(chrome_exe.value(), ShellUtil::CURRENT_USER, create_all_shortcut); } @@ -311,8 +295,8 @@ bool CreateOrUpdateChromeShortcuts(const std::wstring& exe_path, // If these operations are successful, the function returns true, otherwise // false. bool DoPostInstallTasks(HKEY reg_root, - const std::wstring& exe_path, - const std::wstring& install_path, + const FilePath& exe_path, + const FilePath& install_path, const std::wstring& new_chrome_exe, const std::wstring& current_version, const installer::Version& new_version) { @@ -334,12 +318,13 @@ bool DoPostInstallTasks(HKEY reg_root, current_version.c_str(), true); - std::wstring rename_cmd(installer::GetInstallerPathUnderChrome( - install_path, new_version.GetString())); - file_util::AppendToPath(&rename_cmd, - file_util::GetFilenameFromPath(exe_path)); - rename_cmd = L"\"" + rename_cmd + - L"\" --" + installer_util::switches::kRenameChromeExe; + FilePath setup_exe_path(installer::GetInstallerPathUnderChrome(install_path, + new_version.GetString())); + setup_exe_path = setup_exe_path.Append(exe_path.BaseName()); + + std::wstring rename_cmd = L"\"" + setup_exe_path.value() + + L"\" --" + installer_util::switches::kRenameChromeExe; + if (reg_root == HKEY_LOCAL_MACHINE) rename_cmd = rename_cmd + L" --" + installer_util::switches::kSystemLevel; @@ -377,11 +362,12 @@ bool DoPostInstallTasks(HKEY reg_root, // Now we need to register any self registering components and unregister // any that were left from the old version that is being upgraded: if (!current_version.empty()) { - std::wstring old_dll_path(install_path); - file_util::AppendToPath(&old_dll_path, current_version); + FilePath old_dll_path(install_path.Append(current_version)); scoped_ptr<WorkItemList> old_dll_list(WorkItem::CreateWorkItemList()); - if (InstallUtil::BuildDLLRegistrationList(old_dll_path, kDllsToRegister, - kNumDllsToRegister, false, + if (InstallUtil::BuildDLLRegistrationList(old_dll_path.value(), + kDllsToRegister, + kNumDllsToRegister, + false, old_dll_list.get())) { // Don't abort the install as a result of a failure to unregister old // DLLs. @@ -389,10 +375,9 @@ bool DoPostInstallTasks(HKEY reg_root, } } - std::wstring dll_path(install_path); - file_util::AppendToPath(&dll_path, new_version.GetString()); + FilePath dll_path(install_path.Append(new_version.GetString())); scoped_ptr<WorkItemList> dll_list(WorkItem::CreateWorkItemList()); - if (InstallUtil::BuildDLLRegistrationList(dll_path, kDllsToRegister, + if (InstallUtil::BuildDLLRegistrationList(dll_path.value(), kDllsToRegister, kNumDllsToRegister, true, dll_list.get())) { if (!dll_list->Do()) { @@ -422,7 +407,7 @@ bool Is64bit() { return false; } -void RegisterChromeOnMachine(const std::wstring& install_path, +void RegisterChromeOnMachine(const FilePath& install_path, bool system_level, bool make_chrome_default) { // Try to add Chrome to Media Player shim inclusion list. We don't do any @@ -432,16 +417,15 @@ void RegisterChromeOnMachine(const std::wstring& install_path, // Is --make-chrome-default option is given we make Chrome default browser // otherwise we only register it on the machine as a valid browser. - std::wstring chrome_exe(install_path); - file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe); + FilePath chrome_exe(install_path.Append(installer_util::kChromeExe)); LOG(INFO) << "Registering Chrome as browser"; if (make_chrome_default) { int level = ShellUtil::CURRENT_USER; if (system_level) level = level | ShellUtil::SYSTEM_LEVEL; - ShellUtil::MakeChromeDefault(level, chrome_exe, true); + ShellUtil::MakeChromeDefault(level, chrome_exe.value(), true); } else { - ShellUtil::RegisterChromeBrowser(chrome_exe, L"", false); + ShellUtil::RegisterChromeBrowser(chrome_exe.value(), L"", false); } } @@ -470,11 +454,11 @@ void RegisterChromeOnMachine(const std::wstring& install_path, // install_path. If install_path does not exist before calling the function // (typical new install), the function creates install_path during install // and removes the whole directory during rollback. -bool InstallNewVersion(const std::wstring& exe_path, - const std::wstring& archive_path, - const std::wstring& src_path, - const std::wstring& install_path, - const std::wstring& temp_dir, +bool InstallNewVersion(const FilePath& exe_path, + const FilePath& archive_path, + const FilePath& src_path, + const FilePath& install_path, + const FilePath& temp_dir, const HKEY reg_root, const installer::Version& new_version, std::wstring* current_version) { @@ -483,60 +467,59 @@ bool InstallNewVersion(const std::wstring& exe_path, if (InstallUtil::IsChromeFrameProcess()) { // Make sure that we don't end up deleting installed files on next reboot. - if (!RemoveFromMovesPendingReboot(install_path.c_str())) { + if (!RemoveFromMovesPendingReboot(install_path.value().c_str())) { LOG(ERROR) << "Error accessing pending moves value."; } } scoped_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList()); // A temp directory that work items need and the actual install directory. - install_list->AddCreateDirWorkItem(FilePath::FromWStringHack(temp_dir)); - install_list->AddCreateDirWorkItem(FilePath::FromWStringHack(install_path)); + install_list->AddCreateDirWorkItem(temp_dir); + install_list->AddCreateDirWorkItem(install_path); // If it is system level install copy the version folder (since we want to // take the permissions of %ProgramFiles% folder) otherwise just move it. if (reg_root == HKEY_LOCAL_MACHINE) { install_list->AddCopyTreeWorkItem( - AppendPath(src_path, new_version.GetString()), - AppendPath(install_path, new_version.GetString()), + src_path.Append(new_version.GetString()), + install_path.Append(new_version.GetString()), temp_dir, WorkItem::ALWAYS); } else { install_list->AddMoveTreeWorkItem( - AppendPath(src_path, new_version.GetString()), - AppendPath(install_path, new_version.GetString()), + src_path.Append(new_version.GetString()), + install_path.Append(new_version.GetString()), temp_dir); } // Delete any new_chrome.exe if present (we will end up creating a new one // if required) and then copy chrome.exe - std::wstring new_chrome_exe = AppendPath(install_path, - installer_util::kChromeNewExe); + FilePath new_chrome_exe(install_path.Append(installer_util::kChromeNewExe)); BrowserDistribution* dist = BrowserDistribution::GetDistribution(); RegKey chrome_key(reg_root, dist->GetVersionKey().c_str(), KEY_READ); - if (file_util::PathExists(FilePath::FromWStringHack(new_chrome_exe))) + if (file_util::PathExists(new_chrome_exe)) chrome_key.ReadValue(google_update::kRegOldVersionField, current_version); if (current_version->empty()) chrome_key.ReadValue(google_update::kRegVersionField, current_version); chrome_key.Close(); - install_list->AddDeleteTreeWorkItem(new_chrome_exe, std::wstring()); + install_list->AddDeleteTreeWorkItem(new_chrome_exe, FilePath()); install_list->AddCopyTreeWorkItem( - AppendPath(src_path, installer_util::kChromeExe), - AppendPath(install_path, installer_util::kChromeExe), + src_path.Append(installer_util::kChromeExe), + install_path.Append(installer_util::kChromeExe), temp_dir, WorkItem::NEW_NAME_IF_IN_USE, new_chrome_exe); // Extra executable for 64 bit systems. if (Is64bit()) { install_list->AddCopyTreeWorkItem( - AppendPath(src_path, installer::kWowHelperExe), - AppendPath(install_path, installer::kWowHelperExe), + src_path.Append(installer::kWowHelperExe), + install_path.Append(installer::kWowHelperExe), temp_dir, WorkItem::ALWAYS); } // Copy the default Dictionaries only if the folder doesnt exist already install_list->AddCopyTreeWorkItem( - AppendPath(src_path, installer::kDictionaries), - AppendPath(install_path, installer::kDictionaries), + src_path.Append(installer::kDictionaries), + install_path.Append(installer::kDictionaries), temp_dir, WorkItem::IF_NOT_PRESENT); // Copy installer in install directory and @@ -550,7 +533,7 @@ bool InstallNewVersion(const std::wstring& exe_path, // Delete any old_chrome.exe if present. install_list->AddDeleteTreeWorkItem( - AppendPath(install_path, installer_util::kChromeOldExe), std::wstring()); + install_path.Append(installer_util::kChromeOldExe), FilePath()); // Create Version key (if not already present) and set the new Chrome // version as last step. @@ -567,7 +550,8 @@ bool InstallNewVersion(const std::wstring& exe_path, if (!install_list->Do() || !DoPostInstallTasks(reg_root, exe_path, install_path, - new_chrome_exe, *current_version, new_version)) { + new_chrome_exe.value(), + *current_version, new_version)) { LOG(ERROR) << "Install failed, rolling back... "; install_list->Rollback(); LOG(ERROR) << "Rollback complete. "; @@ -579,33 +563,35 @@ bool InstallNewVersion(const std::wstring& exe_path, } // namespace -std::wstring installer::GetInstallerPathUnderChrome( - const std::wstring& install_path, const std::wstring& new_version) { - std::wstring installer_path(install_path); - file_util::AppendToPath(&installer_path, new_version); - file_util::AppendToPath(&installer_path, installer_util::kInstallerDir); +FilePath installer::GetInstallerPathUnderChrome(const FilePath& install_path, + const std::wstring& new_version) +{ + FilePath installer_path(install_path.Append(new_version)); + installer_path = installer_path.Append(installer_util::kInstallerDir); return installer_path; } installer_util::InstallStatus installer::InstallOrUpdateChrome( - const std::wstring& exe_path, const std::wstring& archive_path, - const std::wstring& install_temp_path, const std::wstring& prefs_path, - const DictionaryValue* prefs, const Version& new_version, + const FilePath& exe_path, + const FilePath& archive_path, + const FilePath& install_temp_path, + const FilePath& prefs_path, + const DictionaryValue* prefs, + const Version& new_version, const Version* installed_version) { bool system_install = false; installer_util::GetDistroBooleanPreference(prefs, installer_util::master_preferences::kSystemLevel, &system_install); - std::wstring install_path(GetChromeInstallPath(system_install)); + FilePath install_path(GetChromeInstallPath(system_install)); if (install_path.empty()) { LOG(ERROR) << "Could not get installation destination path."; return installer_util::INSTALL_FAILED; } else { - LOG(INFO) << "install destination path: " << install_path; + LOG(INFO) << "install destination path: " << install_path.value(); } - std::wstring src_path(install_temp_path); - file_util::AppendToPath(&src_path, std::wstring(kInstallSourceDir)); - file_util::AppendToPath(&src_path, std::wstring(kInstallSourceChromeDir)); + FilePath src_path(install_temp_path.Append(kInstallSourceDir)); + src_path = src_path.Append(kInstallSourceChromeDir); HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; std::wstring current_version; @@ -620,7 +606,7 @@ installer_util::InstallStatus installer::InstallOrUpdateChrome( if (!installed_version) { LOG(INFO) << "First install of version " << new_version.GetString(); result = installer_util::FIRST_INSTALL_SUCCESS; - CopyPreferenceFileForFirstRun(system_install, prefs_path); + CopyPreferenceFileForFirstRun(system_install, FilePath(prefs_path)); } else if (new_version.GetString() == installed_version->GetString()) { LOG(INFO) << "Install repaired of version " << new_version.GetString(); result = installer_util::INSTALL_REPAIRED; diff --git a/chrome/installer/setup/install.h b/chrome/installer/setup/install.h index 305819a..8810803 100644 --- a/chrome/installer/setup/install.h +++ b/chrome/installer/setup/install.h @@ -12,11 +12,13 @@ #include "chrome/installer/util/util_constants.h" #include "chrome/installer/util/version.h" +class FilePath; + namespace installer { // Get path to the installer under Chrome version folder // (for example <path>\Google\Chrome\<Version>\installer) -std::wstring GetInstallerPathUnderChrome(const std::wstring& install_path, - const std::wstring& new_version); +FilePath GetInstallerPathUnderChrome(const FilePath& install_path, + const std::wstring& new_version); // This function installs or updates a new version of Chrome. It returns // install status (failed, new_install, updated etc). @@ -36,9 +38,12 @@ std::wstring GetInstallerPathUnderChrome(const std::wstring& install_path, // Note: since caller unpacks Chrome to install_temp_path\source, the caller // is responsible for cleaning up install_temp_path. installer_util::InstallStatus InstallOrUpdateChrome( - const std::wstring& exe_path, const std::wstring& archive_path, - const std::wstring& install_temp_path, const std::wstring& prefs_path, - const DictionaryValue* prefs, const Version& new_version, + const FilePath& exe_path, + const FilePath& archive_path, + const FilePath& install_temp_path, + const FilePath& prefs_path, + const DictionaryValue* prefs, + const Version& new_version, const Version* installed_version); } diff --git a/chrome/installer/setup/setup_main.cc b/chrome/installer/setup/setup_main.cc index dab45e2..5cfae0d 100644 --- a/chrome/installer/setup/setup_main.cc +++ b/chrome/installer/setup/setup_main.cc @@ -51,23 +51,23 @@ namespace { // is unpacked in the path specified by parameter "path". DWORD UnPackArchive(const std::wstring& archive, bool system_install, const installer::Version* installed_version, - const std::wstring& temp_path, const std::wstring& path, + const FilePath& temp_path, const FilePath& path, bool& incremental_install) { // First uncompress the payload. This could be a differential // update (patch.7z) or full archive (chrome.7z). If this uncompress fails // return with error. std::wstring unpacked_file; - int32 ret = LzmaUtil::UnPackArchive(archive, temp_path, &unpacked_file); + int32 ret = LzmaUtil::UnPackArchive(archive, temp_path.value(), + &unpacked_file); if (ret != NO_ERROR) return ret; - std::wstring uncompressed_archive(temp_path); - file_util::AppendToPath(&uncompressed_archive, installer::kChromeArchive); + FilePath uncompressed_archive(temp_path.Append(installer::kChromeArchive)); // Check if this is differential update and if it is, patch it to the // installer archive that should already be on the machine. We assume // it is a differential installer if chrome.7z is not found. - if (!file_util::PathExists(FilePath::FromWStringHack(uncompressed_archive))) { + if (!file_util::PathExists(uncompressed_archive)) { incremental_install = true; LOG(INFO) << "Differential patch found. Applying to existing archive."; if (!installed_version) { @@ -75,21 +75,20 @@ DWORD UnPackArchive(const std::wstring& archive, bool system_install, << "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)) { + FilePath existing_archive(installer::GetChromeInstallPath(system_install)); + existing_archive = existing_archive.Append(installed_version->GetString()); + existing_archive = existing_archive.Append(installer_util::kInstallerDir); + existing_archive = existing_archive.Append(installer::kChromeArchive); + if (int i = setup_util::ApplyDiffPatch(existing_archive.value(), + unpacked_file, uncompressed_archive.value())) { LOG(ERROR) << "Binary patching failed with error " << i; return i; } } // Unpack the uncompressed archive. - return LzmaUtil::UnPackArchive(uncompressed_archive, path, &unpacked_file); + return LzmaUtil::UnPackArchive(uncompressed_archive.value(), path.value(), + &unpacked_file); } @@ -99,17 +98,14 @@ DWORD UnPackArchive(const std::wstring& archive, bool system_install, // system and a key called 'opv' in the registry. This function will move // new_chrome.exe to chrome.exe and delete 'opv' key in one atomic operation. installer_util::InstallStatus RenameChromeExecutables(bool system_install) { - std::wstring chrome_path(installer::GetChromeInstallPath(system_install)); + FilePath chrome_path(installer::GetChromeInstallPath(system_install)); - std::wstring chrome_exe(chrome_path); - file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe); - std::wstring chrome_old_exe(chrome_path); - file_util::AppendToPath(&chrome_old_exe, installer_util::kChromeOldExe); - std::wstring chrome_new_exe(chrome_path); - file_util::AppendToPath(&chrome_new_exe, installer_util::kChromeNewExe); + FilePath chrome_exe(chrome_path.Append(installer_util::kChromeExe)); + FilePath chrome_old_exe(chrome_path.Append(installer_util::kChromeOldExe)); + FilePath chrome_new_exe(chrome_path.Append(installer_util::kChromeNewExe)); scoped_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList()); - install_list->AddDeleteTreeWorkItem(chrome_old_exe, std::wstring()); + install_list->AddDeleteTreeWorkItem(chrome_old_exe, FilePath()); FilePath temp_path; if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) { LOG(ERROR) << "Failed to create Temp directory " << temp_path.value(); @@ -117,16 +113,16 @@ installer_util::InstallStatus RenameChromeExecutables(bool system_install) { } install_list->AddCopyTreeWorkItem(chrome_new_exe, chrome_exe, - temp_path.ToWStringHack(), + temp_path, WorkItem::IF_DIFFERENT, - std::wstring()); + FilePath()); HKEY reg_root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; BrowserDistribution *dist = BrowserDistribution::GetDistribution(); install_list->AddDeleteRegValueWorkItem(reg_root, dist->GetVersionKey(), google_update::kRegOldVersionField, true); - install_list->AddDeleteTreeWorkItem(chrome_new_exe, std::wstring()); + install_list->AddDeleteTreeWorkItem(chrome_new_exe, FilePath()); install_list->AddDeleteRegValueWorkItem(reg_root, dist->GetVersionKey(), google_update::kRegRenameCmdField, @@ -162,8 +158,7 @@ bool CheckPreInstallConditions(const installer::Version* installed_version, // either does not exist or can be deleted (i.e. is not locked by some other // process). if (!installed_version) { - FilePath install_path = FilePath::FromWStringHack( - installer::GetChromeInstallPath(system_install)); + FilePath install_path(installer::GetChromeInstallPath(system_install)); if (file_util::PathExists(install_path) && !file_util::Delete(install_path, true)) { LOG(ERROR) << "Installation directory " << install_path.value() @@ -214,24 +209,19 @@ installer_util::InstallStatus InstallChrome(const CommandLine& cmd_line, 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)); + FilePath unpack_path(temp_path.Append(installer::kInstallSourceDir)); bool incremental_install = false; if (UnPackArchive(archive, system_level, installed_version, - temp_path.ToWStringHack(), unpack_path, - incremental_install)) { + temp_path, 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)); + LOG(INFO) << "unpacked to " << unpack_path.value(); + FilePath src_path(unpack_path.Append(installer::kInstallSourceChromeDir)); scoped_ptr<installer::Version> - installer_version(setup_util::GetVersionFromDir(src_path)); + installer_version(setup_util::GetVersionFromDir(src_path.value())); if (!installer_version.get()) { LOG(ERROR) << "Did not find any valid version in installer."; install_status = installer_util::INVALID_ARCHIVE; @@ -249,19 +239,17 @@ installer_util::InstallStatus InstallChrome(const CommandLine& cmd_line, } 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, - std::wstring(installer::kChromeArchive)); - std::wstring prefs_source_path = cmd_line.GetSwitchValue( - installer_util::switches::kInstallerData); + FilePath archive_to_copy(temp_path.Append(installer::kChromeArchive)); + FilePath prefs_source_path = cmd_line.GetSwitchValuePath( + WideToASCII(installer_util::switches::kInstallerData)); install_status = installer::InstallOrUpdateChrome( - cmd_line.program(), archive_to_copy, temp_path.ToWStringHack(), + cmd_line.GetProgram(), archive_to_copy, temp_path, 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::INSTALL_FAILED) { - chrome_exe = installer::GetChromeInstallPath(system_level); + chrome_exe = installer::GetChromeInstallPath(system_level).value(); if (chrome_exe.empty()) { // If we failed to construct install path, it means the OS call to // get %ProgramFiles% or %AppData% failed. Report this as failure. @@ -309,12 +297,11 @@ installer_util::InstallStatus InstallChrome(const CommandLine& cmd_line, // and master profile file if present. scoped_ptr<WorkItemList> cleanup_list(WorkItem::CreateWorkItemList()); LOG(INFO) << "Deleting temporary directory " << temp_path.value(); - cleanup_list->AddDeleteTreeWorkItem(temp_path.ToWStringHack(), - std::wstring()); + cleanup_list->AddDeleteTreeWorkItem(temp_path, FilePath()); if (cmd_line.HasSwitch(installer_util::switches::kInstallerData)) { - std::wstring prefs_path = cmd_line.GetSwitchValue( - installer_util::switches::kInstallerData); - cleanup_list->AddDeleteTreeWorkItem(prefs_path, std::wstring()); + FilePath prefs_path = cmd_line.GetSwitchValuePath( + WideToASCII(installer_util::switches::kInstallerData)); + cleanup_list->AddDeleteTreeWorkItem(prefs_path, FilePath()); } cleanup_list->Do(); @@ -340,9 +327,9 @@ installer_util::InstallStatus UninstallChrome(const CommandLine& cmd_line, bool remove_all = !cmd_line.HasSwitch( installer_util::switches::kDoNotRemoveSharedItems); - return installer_setup::UninstallChrome(cmd_line.program(), system_install, - remove_all, force, - cmd_line, cmd_params); + return installer_setup::UninstallChrome(cmd_line.GetProgram(), system_install, + remove_all, force, cmd_line, + cmd_params); } installer_util::InstallStatus ShowEULADialog(const std::wstring& inner_frame) { @@ -394,7 +381,7 @@ bool HandleNonInstallCmdLineOptions(const CommandLine& cmd_line, installer_util::switches::kUpdateSetupExe); LOG(INFO) << "Opening archive " << setup_patch; std::wstring uncompressed_patch; - if (LzmaUtil::UnPackArchive(setup_patch, temp_path.ToWStringHack(), + if (LzmaUtil::UnPackArchive(setup_patch, temp_path.value(), &uncompressed_patch) == NO_ERROR) { std::wstring old_setup_exe = cmd_line.program(); std::wstring new_setup_exe = cmd_line.GetSwitchValue( diff --git a/chrome/installer/setup/uninstall.cc b/chrome/installer/setup/uninstall.cc index 16c07c1..2ffef62 100644 --- a/chrome/installer/setup/uninstall.cc +++ b/chrome/installer/setup/uninstall.cc @@ -70,12 +70,11 @@ bool CurrentUserHasDefaultBrowser(bool system_uninstall) { RegKey key(HKEY_LOCAL_MACHINE, reg_key.c_str()); std::wstring reg_exe; if (key.ReadValue(L"", ®_exe) && reg_exe.length() > 2) { - std::wstring chrome_exe = installer::GetChromeInstallPath(system_uninstall); - file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe); + FilePath chrome_exe(installer::GetChromeInstallPath(system_uninstall)); + chrome_exe = chrome_exe.Append(installer_util::kChromeExe); reg_exe = reg_exe.substr(1, reg_exe.length() - 2); - if ((reg_exe.size() == chrome_exe.size()) && - (std::equal(chrome_exe.begin(), chrome_exe.end(), - reg_exe.begin(), CaseInsensitiveCompare<wchar_t>()))) + FilePath reg_path(reg_exe); + if (chrome_exe == reg_path) return true; } @@ -169,27 +168,29 @@ enum DeleteResult { // Returns DELETE_FAILED if it could not get the path to the install dir. // Returns DELETE_REQUIRES_REBOOT if the files were in use and so were // scheduled for deletion on next reboot. -DeleteResult DeleteFilesAndFolders(const std::wstring& exe_path, - bool system_uninstall, const installer::Version& installed_version, - std::wstring* local_state_path, bool delete_profile) { - std::wstring install_path(installer::GetChromeInstallPath(system_uninstall)); +DeleteResult DeleteFilesAndFolders(const FilePath& exe_path, + bool system_uninstall, + const installer::Version& installed_version, + FilePath* local_state_path, + bool delete_profile) { + FilePath install_path(installer::GetChromeInstallPath(system_uninstall)); if (install_path.empty()) { LOG(ERROR) << "Could not get installation destination path."; return DELETE_FAILED; // Nothing else we can do to uninstall, so we return. } else { - LOG(INFO) << "install destination path: " << install_path; + LOG(INFO) << "install destination path: " << install_path.value(); } // Move setup.exe to the temp path. - std::wstring setup_exe(installer::GetInstallerPathUnderChrome( + FilePath setup_exe(installer::GetInstallerPathUnderChrome( install_path, installed_version.GetString())); - file_util::AppendToPath(&setup_exe, file_util::GetFilenameFromPath(exe_path)); + setup_exe = setup_exe.Append(exe_path.BaseName()); FilePath temp_file; if (!file_util::CreateTemporaryFile(&temp_file)) { LOG(ERROR) << "Failed to create temporary file for setup.exe."; } else { - FilePath setup_exe_path = FilePath::FromWStringHack(setup_exe); + FilePath setup_exe_path(setup_exe); file_util::Move(setup_exe_path, temp_file); } @@ -208,7 +209,7 @@ DeleteResult DeleteFilesAndFolders(const std::wstring& exe_path, if (got_local_state) { FilePath user_local_file( user_local_state.Append(chrome::kLocalStateFilename)); - FilePath path = FilePath::FromWStringHack(*local_state_path); + FilePath path = *local_state_path; if (!file_util::CreateTemporaryFile(&path)) LOG(ERROR) << "Failed to create temporary file for Local State."; else @@ -219,20 +220,21 @@ DeleteResult DeleteFilesAndFolders(const std::wstring& exe_path, DeleteResult result = DELETE_SUCCEEDED; - LOG(INFO) << "Deleting install path " << install_path; + LOG(INFO) << "Deleting install path " << install_path.value(); if (!file_util::Delete(install_path, true)) { - LOG(ERROR) << "Failed to delete folder (1st try): " << install_path; + LOG(ERROR) << "Failed to delete folder (1st try): " << install_path.value(); if (InstallUtil::IsChromeFrameProcess()) { // We don't try killing Chrome processes for Chrome Frame builds since // that is unlikely to help. Instead, schedule files for deletion and // return a value that will trigger a reboot prompt. - ScheduleDirectoryForDeletion(install_path.c_str()); + ScheduleDirectoryForDeletion(install_path.value().c_str()); result = DELETE_REQUIRES_REBOOT; } else { // Try closing any running chrome processes and deleting files once again. CloseAllChromeProcesses(); if (!file_util::Delete(install_path, true)) { - LOG(ERROR) << "Failed to delete folder (2nd try): " << install_path; + LOG(ERROR) << "Failed to delete folder (2nd try): " << + install_path.value(); result = DELETE_FAILED; } } @@ -265,7 +267,7 @@ DeleteResult DeleteFilesAndFolders(const std::wstring& exe_path, } else { // Now check and delete if the parent directories are empty // For example Google\Chrome or Chromium - DeleteEmptyParentDir(install_path); + DeleteEmptyParentDir(install_path.value()); } return result; } @@ -425,9 +427,12 @@ const wchar_t kChromeExtProgId[] = L"ChromiumExt"; } installer_util::InstallStatus installer_setup::UninstallChrome( - const std::wstring& exe_path, bool system_uninstall, - bool remove_all, bool force_uninstall, - const CommandLine& cmd_line, const wchar_t* cmd_params) { + const FilePath& exe_path, + bool system_uninstall, + bool remove_all, + bool force_uninstall, + const CommandLine& cmd_line, + const wchar_t* cmd_params) { installer_util::InstallStatus status = installer_util::UNINSTALL_CONFIRMED; std::wstring suffix; if (!ShellUtil::GetUserSpecificDefaultBrowserSuffix(&suffix)) @@ -517,12 +522,14 @@ installer_util::InstallStatus installer_setup::UninstallChrome( if (installed_version.get()) { // Unregister any dll servers that we may have registered. - std::wstring dll_path(installer::GetChromeInstallPath(system_uninstall)); - file_util::AppendToPath(&dll_path, installed_version->GetString()); + FilePath dll_path(installer::GetChromeInstallPath(system_uninstall)); + dll_path = dll_path.Append(installed_version->GetString()); scoped_ptr<WorkItemList> dll_list(WorkItem::CreateWorkItemList()); - if (InstallUtil::BuildDLLRegistrationList(dll_path, kDllsToRegister, - kNumDllsToRegister, false, + if (InstallUtil::BuildDLLRegistrationList(dll_path.value(), + kDllsToRegister, + kNumDllsToRegister, + false, dll_list.get())) { dll_list->Do(); } @@ -536,11 +543,11 @@ installer_util::InstallStatus installer_setup::UninstallChrome( // and the user's Local State to a temp location. bool delete_profile = (status == installer_util::UNINSTALL_DELETE_PROFILE) || (cmd_line.HasSwitch(installer_util::switches::kDeleteProfile)); - std::wstring local_state_path; + FilePath local_state_path; ret = installer_util::UNINSTALL_SUCCESSFUL; - DeleteResult delete_result = DeleteFilesAndFolders(exe_path, - system_uninstall, *installed_version, &local_state_path, delete_profile); + DeleteResult delete_result = DeleteFilesAndFolders(exe_path, system_uninstall, + *installed_version, &local_state_path, delete_profile); if (delete_result == DELETE_FAILED) { ret = installer_util::UNINSTALL_FAILED; } else if (delete_result == DELETE_REQUIRES_REBOOT) { diff --git a/chrome/installer/setup/uninstall.h b/chrome/installer/setup/uninstall.h index a2320ad..a0be3d6 100644 --- a/chrome/installer/setup/uninstall.h +++ b/chrome/installer/setup/uninstall.h @@ -15,6 +15,8 @@ #include "chrome/installer/util/util_constants.h" #include "chrome/installer/util/version.h" +class FilePath; + namespace installer_setup { // This function removes all Chrome registration related keys. It returns true // if successful, otherwise false. The error code is set in |exit_code|. @@ -42,10 +44,12 @@ void RemoveLegacyRegistryKeys(); // cmd_line: CommandLine that contains information about the command that // was used to launch current uninstaller. // cmd_params: Command line parameters passed to the uninstaller. -installer_util::InstallStatus UninstallChrome( - const std::wstring& exe_path, bool system_uninstall, - bool remove_all, bool force_uninstall, - const CommandLine& cmd_line, const wchar_t* cmd_params); +installer_util::InstallStatus UninstallChrome(const FilePath& exe_path, + bool system_uninstall, + bool remove_all, + bool force_uninstall, + const CommandLine& cmd_line, + const wchar_t* cmd_params); } // namespace installer_setup |