Remove multi-install from chrome/installer/setup.

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>
 
 #include <memory>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/launch.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/shortcut.h"
-#include "base/win/windows_version.h"
-#include "chrome/common/chrome_constants.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/install_worker.h"
 #include "chrome/installer/setup/installer_crash_reporting.h"
+#include "chrome/installer/setup/installer_state.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/setup/update_active_setup_version_work_item.h"
 #include "chrome/installer/util/beacons.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/delete_after_reboot_helper.h"
 #include "chrome/installer/util/delete_old_versions.h"
-#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/installation_state.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/util_constants.h"
 #include "chrome/installer/util/work_item.h"
 #include "chrome/installer/util/work_item_list.h"
 
 namespace {
 
 void LogShortcutOperation(ShellUtil::ShortcutLocation location,
                           BrowserDistribution* dist,
                           const ShellUtil::ShortcutProperties& properties,
                           ShellUtil::ShortcutOperation operation,
@@ skipping 43 matching lines @@
     message.append(base::UTF16ToUTF8(properties.shortcut_name));
   else
     message.append(base::UTF16ToUTF8(dist->GetDisplayName()));
   message.push_back('"');
 
   message.append(" shortcut to ");
   message.append(base::UTF16ToUTF8(properties.target.value()));
   if (properties.has_arguments())
     message.append(base::UTF16ToUTF8(properties.arguments));
 
-  if (properties.pin_to_taskbar &&
-      base::win::GetVersion() >= base::win::VERSION_WIN7) {
+  if (properties.pin_to_taskbar && base::win::CanPinShortcutToTaskbar())
     message.append(" and pinning to the taskbar");
-  }
 
   message.push_back('.');
 
   if (failed)
     LOG(WARNING) << message;
   else
     VLOG(1) << message;
 }
 
 void ExecuteAndLogShortcutOperation(
@@ skipping 96 matching lines @@
         base::PathExists(new_chrome_exe) && current_version->get() &&
         new_version == *current_version->get() ?
         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;
   }
 
-  installer_state.SetStage(installer::REFRESHING_POLICY);
-
-  installer::RefreshElevationPolicy();
-
   if (!current_version->get()) {
     VLOG(1) << "First install of version " << new_version;
     return installer::FIRST_INSTALL_SUCCESS;
   }
 
   if (new_version == **current_version) {
     VLOG(1) << "Install repaired of version " << new_version;
     return installer::INSTALL_REPAIRED;
   }
 
@@ skipping 18 matching lines @@
     return installer::OLD_VERSION_DOWNGRADE;
   }
 
   LOG(ERROR) << "Not sure how we got here while updating"
              << ", new version: " << new_version
              << ", old version: " << **current_version;
 
   return installer::INSTALL_FAILED;
 }
 
-}  // end namespace
+}  // namespace
 
 namespace installer {
 
 void EscapeXmlAttributeValueInSingleQuotes(base::string16* 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);
@@ skipping 156 matching lines @@
 
   ExecuteAndLogShortcutOperation(
       ShellUtil::SHORTCUT_LOCATION_START_MENU_ROOT, dist,
       start_menu_properties, shortcut_operation);
 }
 
 void RegisterChromeOnMachine(const installer::InstallerState& installer_state,
                              const installer::Product& product,
                              bool make_chrome_default,
                              const base::Version& version) {
-  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();
 
   // Register the event log provider for system-level installs only, as it
   // requires admin privileges.
   if (installer_state.system_install())
     RegisterEventLogProvider(installer_state.target_path(), version);
 
@@ skipping 16 matching lines @@
 InstallStatus InstallOrUpdateProduct(
     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 base::Version& new_version) {
-  DCHECK(!installer_state.products().empty());
-
   // TODO(robertshield): Removing the pending on-reboot moves should be done
   // elsewhere.
   // Remove any scheduled MOVEFILE_DELAY_UNTIL_REBOOT entries in the target of
   // this installation. These may have been added during a previous uninstall of
   // the same version.
   LOG_IF(ERROR, !RemoveFromMovesPendingReboot(installer_state.target_path()))
       << "Error accessing pending moves value.";
 
   // Create VisualElementManifest.xml in |src_path| (if required) so that it
   // looks as if it had been extracted from the archive when calling
   // InstallNewVersion() below.
   installer_state.SetStage(CREATING_VISUAL_MANIFEST);
   CreateVisualElementsManifest(src_path, new_version);
 
   std::unique_ptr<base::Version> existing_version;
   InstallStatus result =
       InstallNewVersion(original_state, installer_state, setup_path,
                         archive_path, src_path, install_temp_path, new_version,
                         &existing_version, IsDowngradeAllowed(prefs));
 
   // TODO(robertshield): Everything below this line should instead be captured
   // by WorkItems.
   if (!InstallUtil::GetInstallReturnCode(result)) {
     installer_state.SetStage(UPDATING_CHANNELS);
 
-    // Update the modifiers on the channel values for the product(s) being
-    // installed and for the binaries in case of multi-install.
+    // Strip evidence of multi-install from the "ap" value.
+    // TODO(grt): Consider doing this earlier, prior to any other work, so that
+    // failed updates benefit from the stripping.
     installer_state.UpdateChannels();
 
     installer_state.SetStage(COPYING_PREFERENCES_FILE);
 
     if (result == FIRST_INSTALL_SUCCESS && !prefs_path.empty())
       CopyPreferenceFileForFirstRun(installer_state, prefs_path);
 
     installer_state.SetStage(CREATING_SHORTCUTS);
 
-    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));
+    const Product& chrome_product = installer_state.product();
+    BrowserDistribution* chrome_dist = chrome_product.distribution();
+    const base::FilePath chrome_exe(
+        installer_state.target_path().Append(kChromeExe));
 
-      // Install per-user shortcuts on user-level installs and all-users
-      // shortcuts on system-level installs. Note that Active Setup will take
-      // care of installing missing per-user shortcuts on system-level install
-      // (i.e., quick launch, taskbar pin, and possibly deleted all-users
-      // shortcuts).
-      InstallShortcutLevel install_level = installer_state.system_install() ?
-          ALL_USERS : CURRENT_USER;
+    // Install per-user shortcuts on user-level installs and all-users shortcuts
+    // on system-level installs. Note that Active Setup will take care of
+    // installing missing per-user shortcuts on system-level install (i.e.,
+    // quick launch, taskbar pin, and possibly deleted all-users shortcuts).
+    InstallShortcutLevel install_level =
+        installer_state.system_install() ? ALL_USERS : CURRENT_USER;
 
-      InstallShortcutOperation install_operation =
-          INSTALL_SHORTCUT_REPLACE_EXISTING;
-      if (result == installer::FIRST_INSTALL_SUCCESS ||
-          result == installer::INSTALL_REPAIRED ||
-          !original_state.GetProductState(installer_state.system_install(),
-                                          chrome_dist->GetType())) {
-        // Always create the shortcuts on a new install, a repair install, and
-        // when the Chrome product is being added to the current install.
-        install_operation = INSTALL_SHORTCUT_CREATE_ALL;
-      }
-
-      CreateOrUpdateShortcuts(chrome_exe, *chrome_product, prefs, install_level,
-                              install_operation);
+    InstallShortcutOperation install_operation =
+        INSTALL_SHORTCUT_REPLACE_EXISTING;
+    if (result == installer::FIRST_INSTALL_SUCCESS ||
+        result == installer::INSTALL_REPAIRED ||
+        !original_state.GetProductState(installer_state.system_install(),
+                                        chrome_dist->GetType())) {
+      // Always create the shortcuts on a new install, a repair install, and
+      // when the Chrome product is being added to the current install.
+      install_operation = INSTALL_SHORTCUT_CREATE_ALL;
     }
 
-    if (chrome_product) {
-      // Register Chrome and, if requested, make Chrome the default browser.
-      installer_state.SetStage(REGISTERING_CHROME);
+    CreateOrUpdateShortcuts(chrome_exe, chrome_product, prefs, install_level,
+                            install_operation);
 
-      bool make_chrome_default = false;
-      prefs.GetBool(master_preferences::kMakeChromeDefault,
-                    &make_chrome_default);
+    // Register Chrome and, if requested, make Chrome the default browser.
+    installer_state.SetStage(REGISTERING_CHROME);
 
-      // 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 == NEW_VERSION_UPDATED || result == INSTALL_REPAIRED ||
-          result == OLD_VERSION_DOWNGRADE || result == IN_USE_DOWNGRADE) {
-        prefs.GetBool(master_preferences::kMakeChromeDefaultForUser,
-                      &force_chrome_default_for_user);
-      }
+    bool make_chrome_default = false;
+    prefs.GetBool(master_preferences::kMakeChromeDefault, &make_chrome_default);
 
-      RegisterChromeOnMachine(
-          installer_state, *chrome_product,
-          make_chrome_default || force_chrome_default_for_user, new_version);
+    // 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 == NEW_VERSION_UPDATED || result == INSTALL_REPAIRED ||
+        result == OLD_VERSION_DOWNGRADE || result == IN_USE_DOWNGRADE) {
+      prefs.GetBool(master_preferences::kMakeChromeDefaultForUser,
+                    &force_chrome_default_for_user);
+    }
 
-      if (!installer_state.system_install()) {
-        DCHECK_EQ(chrome_product->distribution(),
-                  BrowserDistribution::GetDistribution());
-        UpdateDefaultBrowserBeaconForPath(
-            installer_state.target_path().Append(installer::kChromeExe));
-      }
+    RegisterChromeOnMachine(
+        installer_state, chrome_product,
+        make_chrome_default || force_chrome_default_for_user, new_version);
+
+    if (!installer_state.system_install()) {
+      DCHECK_EQ(chrome_product.distribution(),
+                BrowserDistribution::GetDistribution());
+      UpdateDefaultBrowserBeaconForPath(
+          installer_state.target_path().Append(installer::kChromeExe));
     }
 
     // Delete files that belong to old versions of Chrome. If that fails during
     // a not-in-use update, launch a --delete-old-version process. If this is an
     // in-use update, a --delete-old-versions process will be launched when
     // executables are renamed.
     installer_state.SetStage(REMOVING_OLD_VERSIONS);
     const bool is_in_use =
         (result == IN_USE_UPDATED || result == IN_USE_DOWNGRADE);
     if (!DeleteOldVersions(installer_state.target_path()) && !is_in_use) {
       const base::FilePath new_version_setup_path =
           installer_state.GetInstallerDirectory(new_version)
               .Append(setup_path.BaseName());
       LaunchDeleteOldVersionsProcess(new_version_setup_path, installer_state);
     }
   }
 
   return result;
 }
 
 void LaunchDeleteOldVersionsProcess(const base::FilePath& setup_path,
                                     const InstallerState& installer_state) {
-  // Deleting old versions is relevant if multi-install binaries are being
-  // updated or if single-install Chrome is.
-  const Product* product =
-      installer_state.FindProduct(BrowserDistribution::CHROME_BINARIES);
-  if (!product)
-    product = installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER);
-  if (!product)
-    return;
-
   base::CommandLine command_line(setup_path);
-  product->AppendProductFlags(&command_line);
+  installer_state.product().AppendProductFlags(&command_line);
   command_line.AppendSwitch(switches::kDeleteOldVersions);
 
   if (installer_state.system_install())
     command_line.AppendSwitch(switches::kSystemLevel);
   // Unconditionally enable verbose logging for now to make diagnosing potential
   // failures possible.
   command_line.AppendSwitch(switches::kVerboseLogging);
 
   base::LaunchOptions launch_options;
   launch_options.start_hidden = true;
   // Make sure not to launch from a version directory. Otherwise, it wouldn't be
   // possible to delete it.
   launch_options.current_directory = setup_path.DirName();
   launch_options.force_breakaway_from_job_ = true;
 
   VLOG(1) << "Launching \"" << command_line.GetCommandLineString()
           << "\" to delete old versions.";
   base::Process process = base::LaunchProcess(command_line, launch_options);
   PLOG_IF(ERROR, !process.IsValid())
       << "Failed to launch \"" << command_line.GetCommandLineString() << "\"";
 }
 
 void HandleOsUpgradeForBrowser(const installer::InstallerState& installer_state,
                                const installer::Product& chrome,
                                const base::Version& installed_version) {
-  DCHECK(chrome.is_chrome());
-
   VLOG(1) << "Updating and registering shortcuts for --on-os-upgrade.";
 
   // Read master_preferences copied beside chrome.exe at install.
   const MasterPreferences prefs(
       installer_state.target_path().AppendASCII(kDefaultMasterPrefs));
 
   // Update shortcuts at this install level (per-user shortcuts on system-level
   // installs will be updated through Active Setup).
   const InstallShortcutLevel level =
       installer_state.system_install() ? ALL_USERS : CURRENT_USER;
@@ skipping 42 matching lines @@
 }
 
 // NOTE: Should the work done here, on Active Setup, change:
 // kActiveSetupMajorVersion in update_active_setup_version_work_item.cc needs to
 // be increased for Active Setup to invoke this again for all users of this
 // install. It may also be invoked again when a system-level chrome install goes
 // through an OS upgrade.
 void HandleActiveSetupForBrowser(const base::FilePath& installation_root,
                                  const installer::Product& chrome,
                                  bool force) {
-  DCHECK(chrome.is_chrome());
-
   std::unique_ptr<WorkItemList> cleanup_list(WorkItem::CreateWorkItemList());
   cleanup_list->set_log_message("Cleanup deprecated per-user registrations");
   cleanup_list->set_rollback_enabled(false);
   cleanup_list->set_best_effort(true);
   AddCleanupDeprecatedPerUserRegistrationsWorkItems(chrome, cleanup_list.get());
   cleanup_list->Do();
 
   // 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 =
       (!force && InstallUtil::IsFirstRunSentinelPresent())
           ? INSTALL_SHORTCUT_REPLACE_EXISTING
           : INSTALL_SHORTCUT_CREATE_EACH_IF_NO_SYSTEM_LEVEL;
 
   // Read master_preferences copied beside chrome.exe at install.
   MasterPreferences prefs(installation_root.AppendASCII(kDefaultMasterPrefs));
   base::FilePath chrome_exe(installation_root.Append(kChromeExe));
   CreateOrUpdateShortcuts(
       chrome_exe, chrome, prefs, CURRENT_USER, install_operation);
 
   UpdateDefaultBrowserBeaconForPath(chrome_exe);
 }
 
 }  // namespace installer