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();

[gab, 2016/12/22 19:05:10]

This is Chrome Frame stuff, separate CL?

-
   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());

[gab, 2016/12/22 19:05:10]

I don't see a change to product.h in this CL? Leave this for a follow-up?

Ditto for all DCHECK(chrome.is_chrome()); strips in this CL

[grt (UTC plus 2), 2017/01/02 10:45:03]

While the change to product.h is in https://codereview.chromium.org/2594113002/,
I thought it made sense to remove this here since there is no codepath that
could lead to is_chrome() being false. It seemed to be in the spirit of removing
multi-install from setup -- setup only processes Chrome. WDYT?

[gab, 2017/01/05 22:08:01]

I think we should leave the DCHECK while Product has logic that make it look
like it could be non-chrome (even though it never is in practice).

[grt (UTC plus 2), 2017/01/06 10:25:53]

Done.

-
   // 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();

[gab, 2016/12/22 19:05:10]

I presume InstallerState and Product will eventually (in a follow-up) become the
same thing if we have only one Product?

[grt (UTC plus 2), 2017/01/02 10:45:03]

Yeah, there will be opportunities for further simplification once all of this
lands. I'm not sure exactly what it will look like when the dust settles, but
some of the layers will certainly be removable.

+    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) {

[gab, 2016/12/22 19:05:10]

Nice, we had two if (chrome_product) {} blocks in a row :-O!

[grt (UTC plus 2), 2017/01/02 10:45:03]

Indeed! I laughed at that one, too.

-      // 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