Merge the installer, installer_util and setup_util namespaces into a single i...

chrome/installer/setup/install.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 "chrome/installer/setup/install.h"
 
 #include <shlobj.h>
 #include <time.h>
 
 #include "base/command_line.h"
@@ skipping 26 matching lines @@
 namespace {
 
 using installer::Products;
 using installer::Product;
 using installer::Package;
 using installer::Version;
 
 void AddChromeToMediaPlayerList() {
   std::wstring reg_path(installer::kMediaPlayerRegPath);
   // registry paths can also be appended like file system path
-  file_util::AppendToPath(&reg_path, installer_util::kChromeExe);
+  file_util::AppendToPath(&reg_path, installer::kChromeExe);
   VLOG(1) << "Adding Chrome to Media player list at " << reg_path;
   scoped_ptr<WorkItem> work_item(WorkItem::CreateCreateRegKeyWorkItem(
       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.";
 }
 
 void AddInstallerCopyTasks(const FilePath& setup_path,
@@ skipping 17 matching lines @@
   } else {
     install_list->AddMoveTreeWorkItem(archive_path.value(), archive_dst.value(),
                                       temp_path.value());
   }
 }
 
 void AppendUninstallCommandLineFlags(CommandLine* uninstall_cmd,
                                      const Product& product) {
   DCHECK(uninstall_cmd);
 
-  uninstall_cmd->AppendSwitch(installer_util::switches::kUninstall);
+  uninstall_cmd->AppendSwitch(installer::switches::kUninstall);
 
   // Append the product-specific uninstall flags.
   product.distribution()->AppendUninstallCommandLineFlags(uninstall_cmd);
   if (product.IsMsi())
-    uninstall_cmd->AppendSwitch(installer_util::switches::kMsi);
+    uninstall_cmd->AppendSwitch(installer::switches::kMsi);
   if (product.system_level())
-    uninstall_cmd->AppendSwitch(installer_util::switches::kSystemLevel);
+    uninstall_cmd->AppendSwitch(installer::switches::kSystemLevel);
 
   // Propagate switches obtained from preferences as well.
-  const installer_util::MasterPreferences& prefs =
-      installer_util::MasterPreferences::ForCurrentProcess();
+  const installer::MasterPreferences& prefs =
+      installer::MasterPreferences::ForCurrentProcess();
   if (prefs.is_multi_install()) {
-    uninstall_cmd->AppendSwitch(installer_util::switches::kMultiInstall);
+    uninstall_cmd->AppendSwitch(installer::switches::kMultiInstall);
   }
   bool value = false;
-  if (prefs.GetBool(installer_util::master_preferences::kVerboseLogging,
+  if (prefs.GetBool(installer::master_preferences::kVerboseLogging,
                     &value) && value)
-    uninstall_cmd->AppendSwitch(installer_util::switches::kVerboseLogging);
+    uninstall_cmd->AppendSwitch(installer::switches::kVerboseLogging);
 }
 
 // This method adds work items to create (or update) Chrome uninstall entry in
 // either the Control Panel->Add/Remove Programs list or in the Omaha client
 // state key if running under an MSI installer.
 void AddUninstallShortcutWorkItems(const FilePath& setup_path,
                                    const Version& new_version,
                                    WorkItemList* install_list,
                                    const Product& product) {
   HKEY reg_root = product.system_level() ? HKEY_LOCAL_MACHINE :
@@ skipping 11 matching lines @@
   FilePath installer_path(
       product.package().GetInstallerDirectory(new_version));
   installer_path = installer_path.Append(setup_path.BaseName());
 
   CommandLine uninstall_arguments(CommandLine::NO_PROGRAM);
   AppendUninstallCommandLineFlags(&uninstall_arguments, product);
 
   std::wstring update_state_key(browser_dist->GetStateKey());
   install_list->AddCreateRegKeyWorkItem(reg_root, update_state_key);
   install_list->AddSetRegValueWorkItem(reg_root, update_state_key,
-      installer_util::kUninstallStringField, installer_path.value(), true);
+      installer::kUninstallStringField, installer_path.value(), true);
   install_list->AddSetRegValueWorkItem(reg_root, update_state_key,
-      installer_util::kUninstallArgumentsField,
+      installer::kUninstallArgumentsField,
       uninstall_arguments.command_line_string(), true);
 
   // MSI installations will manage their own uninstall shortcuts.
   if (!product.IsMsi()) {
     // We need to quote the command line for the Add/Remove Programs dialog.
     CommandLine quoted_uninstall_cmd(installer_path);
     DCHECK_EQ(quoted_uninstall_cmd.command_line_string()[0], '"');
     quoted_uninstall_cmd.AppendArguments(uninstall_arguments, false);
 
     std::wstring uninstall_reg = browser_dist->GetUninstallRegPath();
     install_list->AddCreateRegKeyWorkItem(reg_root, uninstall_reg);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-        installer_util::kUninstallDisplayNameField,
+        installer::kUninstallDisplayNameField,
         browser_dist->GetAppShortCutName(), true);
     install_list->AddSetRegValueWorkItem(reg_root,
-        uninstall_reg, installer_util::kUninstallStringField,
+        uninstall_reg, installer::kUninstallStringField,
         quoted_uninstall_cmd.command_line_string(), true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
                                          L"InstallLocation",
                                          install_path.value(),
                                          true);
 
     // DisplayIcon, NoModify and NoRepair
-    FilePath chrome_icon(install_path.Append(installer_util::kChromeExe));
+    FilePath chrome_icon(install_path.Append(installer::kChromeExe));
     ShellUtil::GetChromeIcon(product.distribution(), chrome_icon.value());
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"DisplayIcon", chrome_icon.value(),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"NoModify", 1, true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"NoRepair", 1, true);
 
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
@@ skipping 54 matching lines @@
       VLOG(1) << "Failed to delete old uninstall shortcut.";
   }
 }
 
 // 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 Package& package,
                                    const FilePath& prefs_source_path) {
   FilePath prefs_dest_path(package.path().AppendASCII(
-      installer_util::kDefaultMasterPrefs));
+      installer::kDefaultMasterPrefs));
   if (!file_util::CopyFile(prefs_source_path, prefs_dest_path)) {
     VLOG(1) << "Failed to copy master preferences from:"
             << prefs_source_path.value() << " gle: " << ::GetLastError();
   }
 }
 
 // This method creates Chrome shortcuts in Start->Programs for all users or
 // only for current user depending on whether it is system wide install or
 // user only install.
 //
 // If first_install is true, it creates shortcuts for launching and
 // uninstalling chrome.
 // If first_install is false, the function only updates the shortcut for
 // uninstalling chrome. According to
 // http://blogs.msdn.com/oldnewthing/archive/2005/11/24/496690.aspx,
 // updating uninstall shortcut should not trigger Windows "new application
 // installed" notification.
 //
 // If the shortcuts do not exist, the function does not recreate them during
 // update.
 bool CreateOrUpdateChromeShortcuts(const FilePath& setup_path,
                                    const Version& new_version,
-                                   installer_util::InstallStatus install_status,
+                                   installer::InstallStatus install_status,
                                    const Product& product,
                                    bool create_all_shortcut,
                                    bool alt_shortcut) {
   // TODO(tommi): Change this function to use WorkItemList.
 #ifndef NDEBUG
-  const installer_util::MasterPreferences& prefs =
-      installer_util::MasterPreferences::ForCurrentProcess();
+  const installer::MasterPreferences& prefs =
+      installer::MasterPreferences::ForCurrentProcess();
   DCHECK(prefs.install_chrome());
 #endif
 
   FilePath shortcut_path;
   int dir_enum = product.system_level() ? base::DIR_COMMON_START_MENU :
                                           base::DIR_START_MENU;
   if (!PathService::Get(dir_enum, &shortcut_path)) {
     LOG(ERROR) << "Failed to get location for shortcut.";
     return false;
   }
@@ skipping 10 matching lines @@
   // - This is a new install or install repair
   // OR
   // - The shortcut already exists in case of updates (user may have deleted
   //   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");
   // Chrome link target
   FilePath chrome_exe(
-      product.package().path().Append(installer_util::kChromeExe));
+      product.package().path().Append(installer::kChromeExe));
 
-  if ((install_status == installer_util::FIRST_INSTALL_SUCCESS) ||
-      (install_status == installer_util::INSTALL_REPAIRED)) {
+  if ((install_status == installer::FIRST_INSTALL_SUCCESS) ||
+      (install_status == installer::INSTALL_REPAIRED)) {
     if (!file_util::PathExists(shortcut_path))
       file_util::CreateDirectoryW(shortcut_path);
 
     VLOG(1) << "Creating shortcut to " << chrome_exe.value() << " at "
             << chrome_link.value();
     ret = ShellUtil::UpdateChromeShortcut(browser_dist, chrome_exe.value(),
         chrome_link.value(), product_desc, true);
   } else if (file_util::PathExists(chrome_link)) {
     VLOG(1) << "Updating shortcut at " << chrome_link.value()
             << " to point to " << chrome_exe.value();
     ret = ShellUtil::UpdateChromeShortcut(browser_dist, chrome_exe.value(),
         chrome_link.value(), product_desc, false);
   } else {
     VLOG(1)
         << "not first or repaired install, link file doesn't exist. status: "
         << install_status;
   }
 
   // Create/update uninstall link if we are not an MSI install. MSI
   // installations are, for the time being, managed only through the
   // Add/Remove Programs dialog.
   // TODO(robertshield): We could add a shortcut to msiexec /X {GUID} here.
   if (ret && !product.IsMsi()) {
     FilePath uninstall_link(shortcut_path);  // Uninstall Chrome link
     uninstall_link = uninstall_link.Append(
         browser_dist->GetUninstallLinkName() + L".lnk");
-    if ((install_status == installer_util::FIRST_INSTALL_SUCCESS) ||
-        (install_status == installer_util::INSTALL_REPAIRED) ||
+    if ((install_status == installer::FIRST_INSTALL_SUCCESS) ||
+        (install_status == installer::INSTALL_REPAIRED) ||
         (file_util::PathExists(uninstall_link))) {
       if (!file_util::PathExists(shortcut_path))
         file_util::CreateDirectory(shortcut_path);
 
       FilePath setup_exe(
           product.package().GetInstallerDirectory(new_version)
               .Append(setup_path.BaseName()));
 
       CommandLine arguments(CommandLine::NO_PROGRAM);
       AppendUninstallCommandLineFlags(&arguments, product);
@@ skipping 88 matching lines @@
     if (!current_version) {
       LOG(ERROR) << "New chrome.exe exists but current version is NULL!";
       return false;
     }
 
     scoped_ptr<WorkItemList> inuse_list(WorkItem::CreateWorkItemList());
     FilePath installer_path(package.GetInstallerDirectory(new_version)
         .Append(setup_path.BaseName()));
 
     CommandLine rename(installer_path);
-    rename.AppendSwitch(installer_util::switches::kRenameChromeExe);
+    rename.AppendSwitch(installer::switches::kRenameChromeExe);
     if (package.system_level())
-      rename.AppendSwitch(installer_util::switches::kSystemLevel);
+      rename.AppendSwitch(installer::switches::kSystemLevel);
 
     if (InstallUtil::IsChromeSxSProcess())
-      rename.AppendSwitch(installer_util::switches::kChromeSxS);
+      rename.AppendSwitch(installer::switches::kChromeSxS);
 
     for (size_t i = 0; i < products.size(); ++i) {
       BrowserDistribution* dist = products[i]->distribution();
       std::wstring version_key(dist->GetVersionKey());
       inuse_list->AddSetRegValueWorkItem(root, version_key,
                                          google_update::kRegOldVersionField,
                                          current_version->GetString(), true);
 
       // Adding this registry entry for all products is overkill.
       // However, as it stands, we don't have a way to know which distribution
@@ skipping 81 matching lines @@
             BrowserDistribution::CHROME_BROWSER);
 
   // 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();
 
   // Is --make-chrome-default option is given we make Chrome default browser
   // otherwise we only register it on the machine as a valid browser.
   FilePath chrome_exe(
-      product.package().path().Append(installer_util::kChromeExe));
+      product.package().path().Append(installer::kChromeExe));
   VLOG(1) << "Registering Chrome as browser: " << chrome_exe.value();
   if (make_chrome_default) {
     int level = ShellUtil::CURRENT_USER;
     if (product.system_level())
       level = level | ShellUtil::SYSTEM_LEVEL;
     ShellUtil::MakeChromeDefault(product.distribution(), level,
                                  chrome_exe.value(), true);
   } else {
     ShellUtil::RegisterChromeBrowser(product.distribution(), chrome_exe.value(),
                                      L"", false);
@@ skipping 13 matching lines @@
 // new_version: new Chrome version that needs to be installed
 // oldest_installed_version: returns the oldest 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_util::InstallStatus InstallNewVersion(
+installer::InstallStatus InstallNewVersion(
     const FilePath& setup_path,
     const FilePath& archive_path,
     const FilePath& src_path,
     const FilePath& temp_dir,
     const Version& new_version,
     scoped_ptr<Version>* current_version,
     const Package& package) {
   DCHECK(current_version);
 
   const Products& products = package.products();
   DCHECK(products.size());
 
   if (FindProduct(products, BrowserDistribution::CHROME_FRAME)) {
     // Make sure that we don't end up deleting installed files on next reboot.
     if (!RemoveFromMovesPendingReboot(package.path().value().c_str())) {
       LOG(ERROR) << "Error accessing pending moves value.";
     }
   }
 
   current_version->reset(package.GetCurrentVersion());
 
   scoped_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList());
   // A temp directory that work items need and the actual install directory.
   install_list->AddCreateDirWorkItem(temp_dir);
   install_list->AddCreateDirWorkItem(package.path());
 
   // Delete any new_chrome.exe if present (we will end up creating a new one
   // if required) and then copy chrome.exe
   FilePath new_chrome_exe(
-      package.path().Append(installer_util::kChromeNewExe));
+      package.path().Append(installer::kChromeNewExe));
 
   install_list->AddDeleteTreeWorkItem(new_chrome_exe);
   install_list->AddCopyTreeWorkItem(
-      src_path.Append(installer_util::kChromeExe).value(),
-      package.path().Append(installer_util::kChromeExe).value(),
+      src_path.Append(installer::kChromeExe).value(),
+      package.path().Append(installer::kChromeExe).value(),
       temp_dir.value(), WorkItem::NEW_NAME_IF_IN_USE, new_chrome_exe.value());
 
   // Extra executable for 64 bit systems.
   if (Is64bit()) {
     install_list->AddCopyTreeWorkItem(
         src_path.Append(installer::kWowHelperExe).value(),
         package.path().Append(installer::kWowHelperExe).value(),
         temp_dir.value(), WorkItem::ALWAYS);
   }
 
@@ skipping 12 matching lines @@
   }
 
   // Copy the default Dictionaries only if the folder doesn't exist already.
   install_list->AddCopyTreeWorkItem(
       src_path.Append(installer::kDictionaries).value(),
       package.path().Append(installer::kDictionaries).value(),
       temp_dir.value(), WorkItem::IF_NOT_PRESENT);
 
   // Delete any old_chrome.exe if present.
   install_list->AddDeleteTreeWorkItem(
-      package.path().Append(installer_util::kChromeOldExe));
+      package.path().Append(installer::kChromeOldExe));
 
   // Copy installer in install directory and
   // add shortcut in Control Panel->Add/Remove Programs.
   AddInstallerCopyTasks(setup_path, archive_path, temp_dir, new_version,
                         install_list.get(), package);
 
   for (size_t i = 0; i < products.size(); ++i) {
     const Product* product = products[i];
 
     AddUninstallShortcutWorkItems(setup_path, new_version, install_list.get(),
@@ skipping 17 matching lines @@
                                          false);   // set during first install
     install_list->AddSetRegValueWorkItem(root, version_key,
                                          google_update::kRegVersionField,
                                          new_version.GetString(),
                                          true);    // overwrite version
   }
 
   if (!install_list->Do() ||
       !DoPostInstallTasks(setup_path, new_chrome_exe, current_version->get(),
                           new_version, package)) {
-    installer_util::InstallStatus result =
+    installer::InstallStatus result =
         file_util::PathExists(new_chrome_exe) && current_version->get() &&
         new_version.IsEqual(*current_version->get()) ?
-        installer_util::SAME_VERSION_REPAIR_FAILED :
-        installer_util::INSTALL_FAILED;
+        installer::SAME_VERSION_REPAIR_FAILED :
+        installer::INSTALL_FAILED;
     LOG(ERROR) << "Install failed, rolling back... result: " << result;
     install_list->Rollback();
     LOG(ERROR) << "Rollback complete. ";
     return result;
   }
 
   if (!current_version->get()) {
     VLOG(1) << "First install of version " << new_version.GetString();
-    return installer_util::FIRST_INSTALL_SUCCESS;
+    return installer::FIRST_INSTALL_SUCCESS;
   }
 
   if (new_version.IsEqual(*current_version->get())) {
     VLOG(1) << "Install repaired of version " << new_version.GetString();
-    return installer_util::INSTALL_REPAIRED;
+    return installer::INSTALL_REPAIRED;
   }
 
   if (new_version.IsHigherThan(current_version->get())) {
     if (file_util::PathExists(new_chrome_exe)) {
       VLOG(1) << "Version updated to " << new_version.GetString()
               << " while running " << (*current_version)->GetString();
-      return installer_util::IN_USE_UPDATED;
+      return installer::IN_USE_UPDATED;
     }
     VLOG(1) << "Version updated to " << new_version.GetString();
-    return installer_util::NEW_VERSION_UPDATED;
+    return installer::NEW_VERSION_UPDATED;
   }
 
   LOG(ERROR) << "Not sure how we got here while updating"
              << ", new version: " << new_version.GetString()
              << ", old version: " << (*current_version)->GetString();
 
-  return installer_util::INSTALL_FAILED;
+  return installer::INSTALL_FAILED;
 }
 
 }  // end namespace
 
 namespace installer {
 
-installer_util::InstallStatus InstallOrUpdateChrome(
+installer::InstallStatus InstallOrUpdateChrome(
     const FilePath& setup_path, const FilePath& archive_path,
     const FilePath& install_temp_path, const FilePath& prefs_path,
-    const installer_util::MasterPreferences& prefs, const Version& new_version,
+    const installer::MasterPreferences& prefs, const Version& new_version,
     const Package& install) {
   bool system_install = install.system_level();
 
   FilePath src_path(install_temp_path);
   src_path = src_path.Append(kInstallSourceDir).Append(kInstallSourceChromeDir);
 
   scoped_ptr<Version> existing_version;
-  installer_util::InstallStatus result = InstallNewVersion(setup_path,
+  installer::InstallStatus result = InstallNewVersion(setup_path,
       archive_path, src_path, install_temp_path, new_version,
       &existing_version, install);
 
   if (!BrowserDistribution::GetInstallReturnCode(result)) {
-    if (result == installer_util::FIRST_INSTALL_SUCCESS)
+    if (result == installer::FIRST_INSTALL_SUCCESS)
       CopyPreferenceFileForFirstRun(install, prefs_path);
 
     bool do_not_create_shortcuts = false;
-    prefs.GetBool(installer_util::master_preferences::kDoNotCreateShortcuts,
+    prefs.GetBool(installer::master_preferences::kDoNotCreateShortcuts,
                   &do_not_create_shortcuts);
 
     // Currently this only creates shortcuts for Chrome, but for other products
     // we might want to create shortcuts.
     const Product* chrome_install =
         FindProduct(install.products(), BrowserDistribution::CHROME_BROWSER);
     if (chrome_install && !do_not_create_shortcuts) {
       bool create_all_shortcut = false;
-      prefs.GetBool(installer_util::master_preferences::kCreateAllShortcuts,
+      prefs.GetBool(installer::master_preferences::kCreateAllShortcuts,
                     &create_all_shortcut);
       bool alt_shortcut = false;
-      prefs.GetBool(installer_util::master_preferences::kAltShortcutText,
+      prefs.GetBool(installer::master_preferences::kAltShortcutText,
                     &alt_shortcut);
       if (!CreateOrUpdateChromeShortcuts(setup_path, new_version, result,
                                          *chrome_install, create_all_shortcut,
                                          alt_shortcut)) {
         PLOG(WARNING) << "Failed to create/update start menu shortcut.";
       }
 
       bool make_chrome_default = false;
-      prefs.GetBool(installer_util::master_preferences::kMakeChromeDefault,
+      prefs.GetBool(installer::master_preferences::kMakeChromeDefault,
                     &make_chrome_default);
 
       // If this is not the user's first Chrome install, but they have chosen
       // Chrome to become their default browser on the download page, we must
       // force it here because the master_preferences file will not get copied
       // into the build.
       bool force_chrome_default_for_user = false;
-      if (result == installer_util::NEW_VERSION_UPDATED ||
-          result == installer_util::INSTALL_REPAIRED) {
+      if (result == installer::NEW_VERSION_UPDATED ||
+          result == installer::INSTALL_REPAIRED) {
         prefs.GetBool(
-            installer_util::master_preferences::kMakeChromeDefaultForUser,
+            installer::master_preferences::kMakeChromeDefaultForUser,
             &force_chrome_default_for_user);
       }
 
       RegisterChromeOnMachine(*chrome_install,
           make_chrome_default || force_chrome_default_for_user);
     }
 
     install.RemoveOldVersionDirectories(existing_version.get() ?
         *existing_version.get() : new_version);
   }
@@ skipping 22 matching lines @@
     success = work_item_list->Do();
     if (!success && rollback_on_failure) {
       work_item_list->Rollback();
     }
   }
 
   return success;
 }
 
 }  // namespace installer