Remove multi-install from chrome/installer/setup.

chrome/installer/setup/setup_main.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/setup_main.h"
 
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 67 matching lines @@
 #include "chrome/installer/util/util_constants.h"
 #include "components/crash/content/app/crash_switches.h"
 #include "components/crash/content/app/run_as_crashpad_handler_win.h"
 #include "content/public/common/content_switches.h"
 
 using installer::InstallerState;
 using installer::InstallationState;
 using installer::MasterPreferences;
 using installer::Product;
 using installer::ProductState;
-using installer::Products;
 
 namespace {
 
 const wchar_t kSystemPrincipalSid[] = L"S-1-5-18";
 const wchar_t kDisplayVersion[] = L"DisplayVersion";
 const wchar_t kMsiDisplayVersionOverwriteDelay[] = L"10";  // seconds as string
 const wchar_t kMsiProductIdPrefix[] = L"EnterpriseProduct";
 
 // Overwrite an existing DisplayVersion as written by the MSI installer
 // with the real version number of Chrome.
@@ skipping 116 matching lines @@
 
 // Returns the MSI product ID from the ClientState key that is populated for MSI
 // installs.  This property is encoded in a value name whose format is
 // "EnterpriseId<GUID>" where <GUID> is the MSI product id.  <GUID> is in the
 // format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.  The id will be returned if
 // found otherwise this method will return an empty string.
 //
 // This format is strange and its provenance is shrouded in mystery but it has
 // the data we need, so use it.
 base::string16 FindMsiProductId(const InstallerState& installer_state,
-                                const Product* product) {
+                                const Product& product) {
   HKEY reg_root = installer_state.root_key();
-  BrowserDistribution* dist = product->distribution();
+  BrowserDistribution* dist = product.distribution();
   DCHECK(dist);
 
   base::win::RegistryValueIterator value_iter(reg_root,
                                               dist->GetStateKey().c_str());
   for (; value_iter.Valid(); ++value_iter) {
     base::string16 value_name(value_iter.Name());
     if (base::StartsWith(value_name, kMsiProductIdPrefix,
                          base::CompareCase::INSENSITIVE_ASCII)) {
       return value_name.substr(arraysize(kMsiProductIdPrefix) - 1);
     }
@@ skipping 93 matching lines @@
         "Setup.Install.ApplyArchivePatchTime.background", elapsed_time);
   } else {
     UMA_HISTOGRAM_LONG_TIMES(
         "Setup.Install.ApplyArchivePatchTime", elapsed_time);
   }
 
   *archive_type = installer::INCREMENTAL_ARCHIVE_TYPE;
   return true;
 }
 
-// In multi-install, adds all products to |installer_state| that are
-// multi-installed and must be updated along with the products already present
-// in |installer_state|.
-void AddExistingMultiInstalls(const InstallationState& original_state,
-                              InstallerState* installer_state) {
-  if (installer_state->is_multi_install()) {
-    for (size_t i = 0; i < BrowserDistribution::NUM_TYPES; ++i) {
-      BrowserDistribution::Type type =
-          static_cast<BrowserDistribution::Type>(i);
-
-      if (!installer_state->FindProduct(type)) {
-        const ProductState* state =
-            original_state.GetProductState(installer_state->system_install(),
-                                           type);
-        if (state) {
-          if (state->is_multi_install()) {
-            installer_state->AddProductFromState(type, *state);
-            VLOG(1) << "Product already installed and must be included: "
-                    << BrowserDistribution::GetSpecificDistribution(type)
-                           ->GetDisplayName();
-          }
-        } else if (type == BrowserDistribution::CHROME_BROWSER) {
-          // Chrome is not installed from Google Update's point of view (missing
-          // "pv" in its Clients key). This is an edge case resulting from
-          // either local tampering or from a bug when a multi-install Chrome
-          // Frame was uninstalled; see https://crbug.com/579627. Check to see
-          // if any user has run Chrome within the last 28 days.
-          const bool is_used = IsChromeActivelyUsed(*installer_state);
-          UMA_HISTOGRAM_BOOLEAN("Setup.Install.StrandedChromeIsUsed", is_used);
-          if (is_used) {
-            // Add Chrome to the set of products to update to avoid leaving it
-            // behind.
-            std::unique_ptr<Product> multi_chrome(new Product(
-                BrowserDistribution::GetSpecificDistribution(type)));
-            multi_chrome->SetOption(installer::kOptionMultiInstall, true);
-            Product* chrome = installer_state->AddProduct(&multi_chrome);
-            VLOG(1) << "Broken install of product to be included for repair: "
-                    << chrome->distribution()->GetDisplayName();
-          }  // else uninstall the binaries in UninstallBinariesIfUnused.
-        }
-      }
-    }
-  }
-}
-
 void RecordNumDeleteOldVersionsAttempsBeforeAbort(int num_attempts) {
   UMA_HISTOGRAM_COUNTS_100(
       "Setup.Install.NumDeleteOldVersionsAttemptsBeforeAbort", num_attempts);
 }
 
 // Repetitively attempts to delete all files that belong to old versions of
 // Chrome from |install_dir|. Waits 15 seconds before the first attempt and 5
 // minutes after each unsuccessful attempt. Returns when no files that belong to
 // an old version of Chrome remain or when another process tries to acquire the
 // SetupSingleton.
@@ skipping 55 matching lines @@
 // setup.exe command line. This function assumes an in-use update has happened
 // for Chrome so there should be a file called new_chrome.exe on the file
 // 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.
 // This function also deletes elevation policies associated with the old version
 // if they exist. |setup_exe| is the path to the current executable.
 installer::InstallStatus RenameChromeExecutables(
     const base::FilePath& setup_exe,
     const InstallationState& original_state,
     InstallerState* installer_state) {
-  // See what products are already installed in multi mode.  When we do the
-  // rename for multi installs, we must update all installations since they
-  // share the binaries.
-  AddExistingMultiInstalls(original_state, installer_state);
   const base::FilePath &target_path = installer_state->target_path();
   base::FilePath chrome_exe(target_path.Append(installer::kChromeExe));
   base::FilePath chrome_new_exe(target_path.Append(installer::kChromeNewExe));
   base::FilePath chrome_old_exe(target_path.Append(installer::kChromeOldExe));
 
   // Create a temporary backup directory on the same volume as chrome.exe so
   // that moving in-use files doesn't lead to trouble.
   installer::SelfCleaningTempDir temp_path;
   if (!temp_path.Initialize(target_path.DirName(),
                             installer::kInstallTempDir)) {
     PLOG(ERROR) << "Failed to create Temp directory "
                 << target_path.DirName()
                        .Append(installer::kInstallTempDir).value();
     return installer::RENAME_FAILED;
   }
   std::unique_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList());
   // Move chrome.exe to old_chrome.exe, then move new_chrome.exe to chrome.exe.
   install_list->AddMoveTreeWorkItem(chrome_exe.value(),
                                     chrome_old_exe.value(),
                                     temp_path.path().value(),
                                     WorkItem::ALWAYS_MOVE);
   install_list->AddMoveTreeWorkItem(chrome_new_exe.value(),
                                     chrome_exe.value(),
                                     temp_path.path().value(),
                                     WorkItem::ALWAYS_MOVE);
   install_list->AddDeleteTreeWorkItem(chrome_new_exe, temp_path.path());
 
-  // Add work items to delete the "opv", "cpv", and "cmd" values from all
-  // products we're operating on (which including the multi-install binaries).
-  const Products& products = installer_state->products();
+  // Add work items to delete Chrome's "opv", "cpv", and "cmd" values.
+  // TODO(grt): Clean this up; https://crbug.com/577816.
   HKEY reg_root = installer_state->root_key();
   base::string16 version_key;
-  for (Products::const_iterator it = products.begin(); it < products.end();
-       ++it) {
-    version_key = (*it)->distribution()->GetVersionKey();
-    install_list->AddDeleteRegValueWorkItem(reg_root,
-                                            version_key,
-                                            KEY_WOW64_32KEY,
-                                            google_update::kRegOldVersionField);
-    install_list->AddDeleteRegValueWorkItem(
-        reg_root,
-        version_key,
-        KEY_WOW64_32KEY,
-        google_update::kRegCriticalVersionField);
-    install_list->AddDeleteRegValueWorkItem(reg_root,
-                                            version_key,
-                                            KEY_WOW64_32KEY,
-                                            google_update::kRegRenameCmdField);
-  }
+  version_key = installer_state->product().distribution()->GetVersionKey();
+  install_list->AddDeleteRegValueWorkItem(reg_root, version_key,
+                                          KEY_WOW64_32KEY,
+                                          google_update::kRegOldVersionField);
+  install_list->AddDeleteRegValueWorkItem(
+      reg_root, version_key, KEY_WOW64_32KEY,
+      google_update::kRegCriticalVersionField);
+  install_list->AddDeleteRegValueWorkItem(reg_root, version_key,
+                                          KEY_WOW64_32KEY,
+                                          google_update::kRegRenameCmdField);
   // old_chrome.exe is still in use in most cases, so ignore failures here.
   install_list->AddDeleteTreeWorkItem(chrome_old_exe, temp_path.path())
       ->set_best_effort(true);
 
   installer::InstallStatus ret = installer::RENAME_SUCCESSFUL;
   if (install_list->Do()) {
     installer::LaunchDeleteOldVersionsProcess(setup_exe, *installer_state);
   } else {
     LOG(ERROR) << "Renaming of executables failed. Rolling back any changes.";
     install_list->Rollback();
     ret = installer::RENAME_FAILED;
   }
   // temp_path's dtor will take care of deleting or scheduling itself for
   // deletion at reboot when this scope closes.
   VLOG(1) << "Deleting temporary directory " << temp_path.path().value();
 
   return ret;
 }
 
-// Fail with UNUSED_BINARIES if only the binaries are being updated.
-bool CheckMultiInstallConditions(const InstallationState& original_state,
-                                 InstallerState* installer_state,
-                                 installer::InstallStatus* status) {
-  const Products& products = installer_state->products();
-  DCHECK(products.size());
-
-  const bool system_level = installer_state->system_install();
-
-  if (installer_state->is_multi_install()) {
-    const Product* chrome =
-        installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
-    const Product* binaries =
-        installer_state->FindProduct(BrowserDistribution::CHROME_BINARIES);
-    const ProductState* chrome_state =
-        original_state.GetProductState(system_level,
-                                       BrowserDistribution::CHROME_BROWSER);
-
-    if (binaries) {
-      if (products.size() == 1) {
-        // There are no products aside from the binaries, so there is no update
-        // to be applied. This can happen after multi-install Chrome Frame is
-        // migrated to single-install. This is treated as an update failure
-        // unless the binaries are not in-use, in which case they will be
-        // uninstalled and success will be reported (see handling in wWinMain).
-        VLOG(1) << "No products to be updated.";
-        *status = installer::UNUSED_BINARIES;
-        installer_state->WriteInstallerResult(*status, 0, NULL);
-        return false;
-      }
-    } else {
-      // This will only be hit if --multi-install is given with no products.
-      return true;
-    }
-
-    if (!chrome && chrome_state) {
-      // A product other than Chrome is being installed in multi-install mode,
-      // and Chrome is already present. Add Chrome to the set of products
-      // (making it multi-install in the process) so that it is updated, too.
-      std::unique_ptr<Product> multi_chrome(
-          new Product(BrowserDistribution::GetSpecificDistribution(
-              BrowserDistribution::CHROME_BROWSER)));
-      multi_chrome->SetOption(installer::kOptionMultiInstall, true);
-      chrome = installer_state->AddProduct(&multi_chrome);
-      VLOG(1) << "Upgrading existing Chrome browser in multi-install mode.";
-    }
-  }  // else migrate multi-install Chrome to single-install.
-
-  return true;
-}
-
 // Checks for compatibility between the current state of the system and the
-// desired operation.  Also applies policy that mutates the desired operation;
-// specifically, the |installer_state| object.
+// desired operation.
 // Also blocks simultaneous user-level and system-level installs.  In the case
 // of trying to install user-level Chrome when system-level exists, the
 // existing system-level Chrome is launched.
 // When the pre-install conditions are not satisfied, the result is written to
 // the registry (via WriteInstallerResult), |status| is set appropriately, and
 // false is returned.
 bool CheckPreInstallConditions(const InstallationState& original_state,
-                               InstallerState* installer_state,
+                               const InstallerState& installer_state,
                                installer::InstallStatus* status) {
-  // See what products are already installed in multi mode.  When we do multi
-  // installs, we must upgrade all installations since they share the binaries.
-  AddExistingMultiInstalls(original_state, installer_state);
-
-  if (!CheckMultiInstallConditions(original_state, installer_state, status)) {
-    DCHECK_NE(*status, installer::UNKNOWN_STATUS);
-    return false;
-  }
-
-  const Products& products = installer_state->products();
-  if (products.empty()) {
-    // We haven't been given any products on which to operate.
-    LOG(ERROR)
-        << "Not given any products to install and no products found to update.";
-    *status = installer::CHROME_NOT_INSTALLED;
-    installer_state->WriteInstallerResult(*status,
-        IDS_INSTALL_NO_PRODUCTS_TO_UPDATE_BASE, nullptr);
-    return false;
-  }
-
-  if (!installer_state->system_install()) {
+  if (!installer_state.system_install()) {
     // This is a user-level installation. Make sure that we are not installing
     // on top of an existing system-level installation.
-    for (Products::const_iterator it = products.begin(); it < products.end();
-         ++it) {
-      const Product& product = **it;
-      BrowserDistribution* browser_dist = product.distribution();
+    const Product& product = installer_state.product();
+    BrowserDistribution* browser_dist = product.distribution();
 
-      // Skip over the binaries, as it's okay for them to be at both levels
-      // for different products.
-      if (browser_dist->GetType() == BrowserDistribution::CHROME_BINARIES)
-        continue;
+    const ProductState* user_level_product_state =
+        original_state.GetProductState(false, browser_dist->GetType());
+    const ProductState* system_level_product_state =
+        original_state.GetProductState(true, browser_dist->GetType());
 
-      const ProductState* user_level_product_state =
-          original_state.GetProductState(false, browser_dist->GetType());
-      const ProductState* system_level_product_state =
-          original_state.GetProductState(true, browser_dist->GetType());
+    // Allow upgrades to proceed so that out-of-date versions are not left
+    // around.
+    if (user_level_product_state)
+      return true;
 
-      // Allow upgrades to proceed so that out-of-date versions are not left
-      // around.
-      if (user_level_product_state)
-        continue;
+    // This is a new user-level install...
 
-      // This is a new user-level install...
-
-      if (system_level_product_state) {
-        // ... and the product already exists at system-level.
-        LOG(ERROR) << "Already installed version "
-                   << system_level_product_state->version().GetString()
-                   << " at system-level conflicts with this one at user-level.";
-        if (product.is_chrome()) {
-          // Instruct Google Update to launch the existing system-level Chrome.
-          // There should be no error dialog.
-          base::FilePath install_path(installer::GetChromeInstallPath(
-              true,  // system
-              browser_dist));
-          if (install_path.empty()) {
-            // Give up if we failed to construct the install path.
-            *status = installer::OS_ERROR;
-            installer_state->WriteInstallerResult(*status,
-                                                  IDS_INSTALL_OS_ERROR_BASE,
-                                                  nullptr);
-          } else {
-            *status = installer::EXISTING_VERSION_LAUNCHED;
-            base::FilePath chrome_exe =
-                install_path.Append(installer::kChromeExe);
-            base::CommandLine cmd(chrome_exe);
-            cmd.AppendSwitch(switches::kForceFirstRun);
-            installer_state->WriteInstallerResult(
-                *status, IDS_INSTALL_EXISTING_VERSION_LAUNCHED_BASE, nullptr);
-            VLOG(1) << "Launching existing system-level chrome instead.";
-            base::LaunchProcess(cmd, base::LaunchOptions());
-          }
-        } else {
-          // It's no longer possible for |product| to be anything other than
-          // Chrome.
-          NOTREACHED();
-        }
-        return false;
+    if (system_level_product_state) {
+      // ... and the product already exists at system-level.
+      LOG(ERROR) << "Already installed version "
+                 << system_level_product_state->version().GetString()
+                 << " at system-level conflicts with this one at user-level.";
+      // Instruct Google Update to launch the existing system-level Chrome.
+      // There should be no error dialog.
+      base::FilePath install_path(
+          installer::GetChromeInstallPath(true,  // system
+                                          browser_dist));
+      if (install_path.empty()) {
+        // Give up if we failed to construct the install path.
+        *status = installer::OS_ERROR;
+        installer_state.WriteInstallerResult(*status, IDS_INSTALL_OS_ERROR_BASE,
+                                             nullptr);
+      } else {
+        *status = installer::EXISTING_VERSION_LAUNCHED;
+        base::FilePath chrome_exe = install_path.Append(installer::kChromeExe);
+        base::CommandLine cmd(chrome_exe);
+        cmd.AppendSwitch(switches::kForceFirstRun);
+        installer_state.WriteInstallerResult(
+            *status, IDS_INSTALL_EXISTING_VERSION_LAUNCHED_BASE, nullptr);
+        VLOG(1) << "Launching existing system-level chrome instead.";
+        base::LaunchProcess(cmd, base::LaunchOptions());
       }
+      return false;
     }
   }
 
   return true;
 }
 
 // Initializes |temp_path| to "Temp" within the target directory, and
 // |unpack_path| to a random directory beginning with "source" within
 // |temp_path|. Returns false on error.
 bool CreateTemporaryAndUnpackDirectories(
@@ skipping 42 matching lines @@
   return installer::UninstallProduct(
       original_state, installer_state, setup_exe, product, remove_all,
       force_uninstall, cmd_line);
 }
 
 installer::InstallStatus UninstallProducts(
     const InstallationState& original_state,
     const InstallerState& installer_state,
     const base::FilePath& setup_exe,
     const base::CommandLine& cmd_line) {
-  const Products& products = installer_state.products();
-
   // System-level Chrome will be launched via this command if its program gets
   // set below.
   base::CommandLine system_level_cmd(base::CommandLine::NO_PROGRAM);
 
-  const Product* chrome =
-      installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER);
-  if (chrome) {
-    // InstallerState::Initialize always puts Chrome first, and we rely on that
-    // here for this reason: if Chrome is in-use, the user will be prompted to
-    // confirm uninstallation.  Upon cancel, we should not continue with the
-    // other products.
-    DCHECK(products[0]->is_chrome());
-
-    if (cmd_line.HasSwitch(installer::switches::kSelfDestruct) &&
-        !installer_state.system_install()) {
-      BrowserDistribution* dist = chrome->distribution();
-      const base::FilePath system_exe_path(
-          installer::GetChromeInstallPath(true, dist)
-              .Append(installer::kChromeExe));
-      system_level_cmd.SetProgram(system_exe_path);
-    }
-  }
-  if (installer_state.FindProduct(BrowserDistribution::CHROME_BINARIES)) {
-    // Chrome Binaries should be last; if something else is cancelled, they
-    // should stay.
-    DCHECK(products.back()->is_chrome_binaries());
+  const Product& chrome = installer_state.product();
+  if (cmd_line.HasSwitch(installer::switches::kSelfDestruct) &&
+      !installer_state.system_install()) {
+    BrowserDistribution* dist = chrome.distribution();
+    const base::FilePath system_exe_path(
+        installer::GetChromeInstallPath(true, dist)
+            .Append(installer::kChromeExe));
+    system_level_cmd.SetProgram(system_exe_path);
   }
 
   installer::InstallStatus install_status = installer::UNINSTALL_SUCCESSFUL;
-  installer::InstallStatus prod_status = installer::UNKNOWN_STATUS;
   const bool force = cmd_line.HasSwitch(installer::switches::kForceUninstall);
   const bool remove_all = !cmd_line.HasSwitch(
       installer::switches::kDoNotRemoveSharedItems);
 
-  for (Products::const_iterator it = products.begin();
-       install_status != installer::UNINSTALL_CANCELLED && it < products.end();
-       ++it) {
-    prod_status = UninstallProduct(original_state, installer_state, setup_exe,
-        cmd_line, remove_all, force, **it);
-    if (prod_status != installer::UNINSTALL_SUCCESSFUL)
-      install_status = prod_status;
-  }
+  install_status =
+      UninstallProduct(original_state, installer_state, setup_exe, cmd_line,
+                       remove_all, force, installer_state.product());
 
   installer::CleanUpInstallationDirectoryAfterUninstall(
       original_state, installer_state, setup_exe, &install_status);
 
   // The app and vendor dirs may now be empty. Make a last-ditch attempt to
   // delete them.
   installer::DeleteChromeDirectoriesIfEmpty(installer_state.target_path());
 
   // Trigger Active Setup if it was requested for the chrome product. This needs
   // to be done after the UninstallProduct calls as some of them might
   // otherwise terminate the process launched by TriggerActiveSetupCommand().
-  if (chrome && cmd_line.HasSwitch(installer::switches::kTriggerActiveSetup))
+  if (cmd_line.HasSwitch(installer::switches::kTriggerActiveSetup))
     InstallUtil::TriggerActiveSetupCommand();
 
   if (!system_level_cmd.GetProgram().empty())
     base::LaunchProcess(system_level_cmd, base::LaunchOptions());
 
   // Tell Google Update that an uninstall has taken place.
   // Ignore the return value: success or failure of Google Update
   // has no bearing on the success or failure of Chrome's uninstallation.
   google_update::UninstallGoogleUpdate(installer_state.system_install());
 
   return install_status;
 }
 
-// Uninstall the binaries if they are the only product present and they're not
-// in-use.
-void UninstallBinariesIfUnused(
-    const InstallationState& original_state,
-    const InstallerState& installer_state,
-    installer::InstallStatus* install_status) {
-  // Early exit if the binaries are still in use.
-  if (*install_status != installer::UNUSED_BINARIES ||
-      installer_state.AreBinariesInUse(original_state)) {
-    return;
-  }
-
-  LOG(INFO) << "Uninstalling unused binaries";
-  installer_state.SetStage(installer::UNINSTALLING_BINARIES);
-
-  // Create an InstallerState that represents a force uninstall of Chrome
-  // residing with the installed version of the binaries. This will result in
-  // removing Chrome and all of its program files and associated registrations
-  // (aside from user data).
-  const ProductState* binaries_state =
-      original_state.GetProductState(installer_state.system_install(),
-                                     BrowserDistribution::CHROME_BINARIES);
-  base::CommandLine uninstall_cmd(binaries_state->uninstall_command());
-  uninstall_cmd.AppendSwitch(installer::switches::kChrome);
-  uninstall_cmd.AppendSwitch(installer::switches::kForceUninstall);
-  MasterPreferences uninstall_prefs(uninstall_cmd);
-  InstallerState uninstall_state;
-  uninstall_state.Initialize(uninstall_cmd, uninstall_prefs, original_state);
-  *install_status = UninstallProducts(original_state, uninstall_state,
-                                      uninstall_cmd.GetProgram(),
-                                      uninstall_cmd);
-
-  // Report that the binaries were uninstalled if they were. This translates
-  // into a successful install/update return code.
-  if (IsUninstallSuccess(*install_status)) {
-    *install_status = installer::UNUSED_BINARIES_UNINSTALLED;
-#if defined(GOOGLE_CHROME_BUILD)
-    // Write the result for the sake of Google Update in Google Chrome builds,
-    // but skip this for Chromium builds. The reason is a bit icky: Chromium
-    // builds lump the "ClientState" and "Clients" keys into a single key.  As a
-    // consequence, writing this value causes Software\Chromium to be re-created
-    // after it was deleted during the uninstall. Google Chrome builds don't
-    // suffer this since the two keys are distinct and have different lifetimes.
-    installer_state.WriteInstallerResult(*install_status, 0, NULL);
-#endif
-  }
-}
-
 installer::InstallStatus InstallProducts(
     const InstallationState& original_state,
     const base::FilePath& setup_exe,
     const base::CommandLine& cmd_line,
     const MasterPreferences& prefs,
     InstallerState* installer_state,
     base::FilePath* installer_directory) {
   DCHECK(installer_state);
   const bool system_install = installer_state->system_install();
   installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
   installer::ArchiveType archive_type = installer::UNKNOWN_ARCHIVE_TYPE;
   installer_state->SetStage(installer::PRECONDITIONS);
   // Remove any legacy "-multifail" or "-stage:*" values from the product's
   // "ap" value.
   BrowserDistribution::GetSpecificDistribution(installer_state->state_type())->
       UpdateInstallStatus(system_install, archive_type, install_status);
 
   // Drop to background processing mode if the process was started below the
   // normal process priority class. This is done here because InstallProducts-
   // Helper has read-only access to the state and because the action also
   // affects everything else that runs below.
   bool entered_background_mode = installer::AdjustProcessPriority();
   installer_state->set_background_mode(entered_background_mode);
   VLOG_IF(1, entered_background_mode) << "Entered background processing mode.";
 
-  if (CheckPreInstallConditions(original_state, installer_state,
+  if (CheckPreInstallConditions(original_state, *installer_state,
                                 &install_status)) {
     VLOG(1) << "Installing to " << installer_state->target_path().value();
     install_status = InstallProductsHelper(
         original_state, setup_exe, cmd_line, prefs, *installer_state,
         installer_directory, &archive_type);
   } else {
     // CheckPreInstallConditions must set the status on failure.
     DCHECK_NE(install_status, installer::UNKNOWN_STATUS);
   }
 
   // Delete the master preferences file if present. Note that we do not care
   // about rollback here and we schedule for deletion on reboot if the delete
   // fails. As such, we do not use DeleteTreeWorkItem.
   if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
     base::FilePath prefs_path(cmd_line.GetSwitchValuePath(
         installer::switches::kInstallerData));
     if (!base::DeleteFile(prefs_path, false)) {
       LOG(ERROR) << "Failed deleting master preferences file "
                  << prefs_path.value()
                  << ", scheduling for deletion after reboot.";
       ScheduleFileSystemEntityForDeletion(prefs_path);
     }
   }
 
-  const Products& products = installer_state->products();
-  for (Products::const_iterator it = products.begin(); it < products.end();
-       ++it) {
-    (*it)->distribution()->UpdateInstallStatus(
-        system_install, archive_type, install_status);
-  }
-
-  // Handle installer::UNUSED_BINARIES returned by CheckPreInstallConditions.
-  UninstallBinariesIfUnused(original_state, *installer_state, &install_status);
+  installer_state->product().distribution()->UpdateInstallStatus(
+      system_install, archive_type, install_status);
 
   return install_status;
 }
 
 installer::InstallStatus ShowEULADialog(const base::string16& inner_frame) {
   VLOG(1) << "About to show EULA";
   base::string16 eula_path = installer::GetLocalizedEulaResource();
   if (eula_path.empty()) {
     LOG(ERROR) << "No EULA path available";
     return installer::EULA_REJECTED;
@@ skipping 166 matching lines @@
     if (installer::EULA_REJECTED != *exit_code) {
       if (GoogleUpdateSettings::SetEULAConsent(
               *original_state, BrowserDistribution::GetDistribution(), true)) {
         CreateEULASentinel(BrowserDistribution::GetDistribution());
       }
     }
   } else if (cmd_line.HasSwitch(installer::switches::kConfigureUserSettings)) {
     // NOTE: Should the work done here, on kConfigureUserSettings, change:
     // kActiveSetupVersion in install_worker.cc needs to be increased for Active
     // Setup to invoke this again for all users of this install.
-    const Product* chrome_install =
-        installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
+    const Product& chrome_install = installer_state->product();
     installer::InstallStatus status = installer::INVALID_STATE_FOR_OPTION;
-    if (chrome_install && installer_state->system_install()) {
+    if (installer_state->system_install()) {
       bool force =
           cmd_line.HasSwitch(installer::switches::kForceConfigureUserSettings);
       installer::HandleActiveSetupForBrowser(installer_state->target_path(),
-                                             *chrome_install, force);
+                                             chrome_install, force);
       status = installer::INSTALL_REPAIRED;
     } else {
-      LOG(DFATAL) << "chrome_install:" << chrome_install
-                  << ", system_install:" << installer_state->system_install();
+      LOG(DFATAL)
+          << "--configure-user-settings is incompatible with user-level";
     }
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } else if (cmd_line.HasSwitch(installer::switches::kRegisterDevChrome)) {
     installer::InstallStatus status = RegisterDevChrome(
         *original_state, *installer_state, setup_exe, cmd_line);
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } else if (cmd_line.HasSwitch(installer::switches::kRegisterChromeBrowser)) {
     installer::InstallStatus status = installer::UNKNOWN_STATUS;
-    const Product* chrome_install =
-        installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
-    if (chrome_install) {
-      // If --register-chrome-browser option is specified, register all
-      // Chrome protocol/file associations, as well as register it as a valid
-      // browser for Start Menu->Internet shortcut. This switch will also
-      // register Chrome as a valid handler for a set of URL protocols that
-      // Chrome may become the default handler for, either by the user marking
-      // Chrome as the default browser, through the Windows Default Programs
-      // control panel settings, or through website use of
-      // registerProtocolHandler. These protocols are found in
-      // ShellUtil::kPotentialProtocolAssociations.
-      // The --register-url-protocol will additionally register Chrome as a
-      // potential handler for the supplied protocol, and is used if a website
-      // registers a handler for a protocol not found in
-      // ShellUtil::kPotentialProtocolAssociations.
-      // These options should only be used when setup.exe is launched with admin
-      // rights. We do not make any user specific changes with this option.
-      DCHECK(IsUserAnAdmin());
-      base::FilePath chrome_exe(cmd_line.GetSwitchValuePath(
-          installer::switches::kRegisterChromeBrowser));
-      base::string16 suffix;
-      if (cmd_line.HasSwitch(
-          installer::switches::kRegisterChromeBrowserSuffix)) {
-        suffix = cmd_line.GetSwitchValueNative(
-            installer::switches::kRegisterChromeBrowserSuffix);
-      }
-      if (cmd_line.HasSwitch(installer::switches::kRegisterURLProtocol)) {
-        base::string16 protocol = cmd_line.GetSwitchValueNative(
-            installer::switches::kRegisterURLProtocol);
-        // ShellUtil::RegisterChromeForProtocol performs all registration
-        // done by ShellUtil::RegisterChromeBrowser, as well as registering
-        // with Windows as capable of handling the supplied protocol.
-        if (ShellUtil::RegisterChromeForProtocol(
-                chrome_install->distribution(), chrome_exe, suffix, protocol,
-                false))
-          status = installer::IN_USE_UPDATED;
-      } else {
-        if (ShellUtil::RegisterChromeBrowser(chrome_install->distribution(),
-            chrome_exe, suffix, false))
-          status = installer::IN_USE_UPDATED;
-      }
+    const Product& chrome_install = installer_state->product();
+    // If --register-chrome-browser option is specified, register all Chrome
+    // protocol/file associations, as well as register it as a valid browser for
+    // Start Menu->Internet shortcut. This switch will also register Chrome as a
+    // valid handler for a set of URL protocols that Chrome may become the
+    // default handler for, either by the user marking Chrome as the default
+    // browser, through the Windows Default Programs control panel settings, or
+    // through website use of registerProtocolHandler. These protocols are found
+    // in ShellUtil::kPotentialProtocolAssociations.  The
+    // --register-url-protocol will additionally register Chrome as a potential
+    // handler for the supplied protocol, and is used if a website registers a
+    // handler for a protocol not found in
+    // ShellUtil::kPotentialProtocolAssociations.  These options should only be
+    // used when setup.exe is launched with admin rights. We do not make any
+    // user specific changes with this option.
+    DCHECK(IsUserAnAdmin());
+    base::FilePath chrome_exe(cmd_line.GetSwitchValuePath(
+        installer::switches::kRegisterChromeBrowser));
+    base::string16 suffix;
+    if (cmd_line.HasSwitch(installer::switches::kRegisterChromeBrowserSuffix)) {
+      suffix = cmd_line.GetSwitchValueNative(
+          installer::switches::kRegisterChromeBrowserSuffix);
+    }
+    if (cmd_line.HasSwitch(installer::switches::kRegisterURLProtocol)) {
+      base::string16 protocol = cmd_line.GetSwitchValueNative(
+          installer::switches::kRegisterURLProtocol);
+      // ShellUtil::RegisterChromeForProtocol performs all registration
+      // done by ShellUtil::RegisterChromeBrowser, as well as registering
+      // with Windows as capable of handling the supplied protocol.
+      if (ShellUtil::RegisterChromeForProtocol(chrome_install.distribution(),
+                                               chrome_exe, suffix, protocol,
+                                               false))
+        status = installer::IN_USE_UPDATED;
     } else {
-      LOG(DFATAL) << "Can't register browser - Chrome distribution not found";
+      if (ShellUtil::RegisterChromeBrowser(chrome_install.distribution(),
+                                           chrome_exe, suffix, false))
+        status = installer::IN_USE_UPDATED;
     }
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } else if (cmd_line.HasSwitch(installer::switches::kDeleteOldVersions) ||
              cmd_line.HasSwitch(installer::switches::kRenameChromeExe)) {
     std::unique_ptr<installer::SetupSingleton> setup_singleton(
         installer::SetupSingleton::Acquire(
             cmd_line, MasterPreferences::ForCurrentProcess(), original_state,
             installer_state));
     if (!setup_singleton) {
       *exit_code = installer::SETUP_SINGLETON_ACQUISITION_FAILED;
     } else if (cmd_line.HasSwitch(installer::switches::kDeleteOldVersions)) {
-      // In multi-install mode, determine what products are installed to
-      // populate the target_path() used below.
-      AddExistingMultiInstalls(*original_state, installer_state);
-
       *exit_code = RepeatDeleteOldVersions(installer_state->target_path(),
                                            *setup_singleton);
     } else {
       DCHECK(cmd_line.HasSwitch(installer::switches::kRenameChromeExe));
       *exit_code =
           RenameChromeExecutables(setup_exe, *original_state, installer_state);
     }
   } else if (cmd_line.HasSwitch(
                  installer::switches::kRemoveChromeRegistration)) {
     // This is almost reverse of --register-chrome-browser option above.
     // Here we delete Chrome browser registration. This option should only
     // be used when setup.exe is launched with admin rights. We do not
     // make any user specific changes in this option.
     base::string16 suffix;
     if (cmd_line.HasSwitch(
             installer::switches::kRegisterChromeBrowserSuffix)) {
       suffix = cmd_line.GetSwitchValueNative(
           installer::switches::kRegisterChromeBrowserSuffix);
     }
     installer::InstallStatus tmp = installer::UNKNOWN_STATUS;
-    const Product* chrome_install =
-        installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
-    DCHECK(chrome_install);
-    if (chrome_install) {
-      installer::DeleteChromeRegistrationKeys(*installer_state,
-          chrome_install->distribution(), HKEY_LOCAL_MACHINE, suffix, &tmp);
-    }
+    const Product& chrome_install = installer_state->product();
+    installer::DeleteChromeRegistrationKeys(*installer_state,
+                                            chrome_install.distribution(),
+                                            HKEY_LOCAL_MACHINE, suffix, &tmp);
     *exit_code = tmp;
   } else if (cmd_line.HasSwitch(installer::switches::kOnOsUpgrade)) {
-    const Product* chrome_install =
-        installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
+    const Product& chrome_install = installer_state->product();
     installer::InstallStatus status = installer::INVALID_STATE_FOR_OPTION;
-    if (chrome_install) {
-      std::unique_ptr<FileVersionInfo> version_info(
-          FileVersionInfo::CreateFileVersionInfo(setup_exe));
-      const base::Version installed_version(
-          base::UTF16ToUTF8(version_info->product_version()));
-      if (installed_version.IsValid()) {
-        installer::HandleOsUpgradeForBrowser(*installer_state, *chrome_install,
-                                             installed_version);
-        status = installer::INSTALL_REPAIRED;
-      } else {
-        LOG(DFATAL) << "Failed to extract product version from "
-                    << setup_exe.value();
-      }
+    std::unique_ptr<FileVersionInfo> version_info(
+        FileVersionInfo::CreateFileVersionInfo(setup_exe));
+    const base::Version installed_version(
+        base::UTF16ToUTF8(version_info->product_version()));
+    if (installed_version.IsValid()) {
+      installer::HandleOsUpgradeForBrowser(*installer_state, chrome_install,
+                                           installed_version);
+      status = installer::INSTALL_REPAIRED;
     } else {
-      LOG(DFATAL) << "Chrome product not found.";
+      LOG(DFATAL) << "Failed to extract product version from "
+                  << setup_exe.value();
     }
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } else if (cmd_line.HasSwitch(installer::switches::kInactiveUserToast)) {
     // Launch the inactive user toast experiment.
     int flavor = -1;
     base::StringToInt(cmd_line.GetSwitchValueNative(
         installer::switches::kInactiveUserToast), &flavor);
     std::string experiment_group =
         cmd_line.GetSwitchValueASCII(installer::switches::kExperimentGroup);
     DCHECK_NE(-1, flavor);
     if (flavor == -1) {
       *exit_code = installer::UNKNOWN_STATUS;
     } else {
       // This code is called (via setup.exe relaunch) only if a product is known
       // to run user experiments, so no check is required.
-      const Products& products = installer_state->products();
-      for (Products::const_iterator it = products.begin(); it < products.end();
-           ++it) {
-        const Product& product = **it;
-        installer::InactiveUserToastExperiment(
-            flavor, base::ASCIIToUTF16(experiment_group), product,
-            installer_state->target_path());
-      }
+      installer::InactiveUserToastExperiment(
+          flavor, base::ASCIIToUTF16(experiment_group),
+          installer_state->product(), installer_state->target_path());
     }
   } else if (cmd_line.HasSwitch(installer::switches::kSystemLevelToast)) {
-    const Products& products = installer_state->products();
-    for (Products::const_iterator it = products.begin(); it < products.end();
-         ++it) {
-      const Product& product = **it;
-      BrowserDistribution* browser_dist = product.distribution();
-      // We started as system-level and have been re-launched as user level
-      // to continue with the toast experiment.
-      base::Version installed_version;
-      InstallUtil::GetChromeVersion(browser_dist, true, &installed_version);
-      if (!installed_version.IsValid()) {
-        LOG(ERROR) << "No installation of "
-                   << browser_dist->GetDisplayName()
-                   << " found for system-level toast.";
-      } else {
-        product.LaunchUserExperiment(
-            setup_exe, installer::REENTRY_SYS_UPDATE, true);
-      }
+    const Product& product = installer_state->product();
+    BrowserDistribution* browser_dist = product.distribution();
+    // We started as system-level and have been re-launched as user level
+    // to continue with the toast experiment.
+    base::Version installed_version;
+    InstallUtil::GetChromeVersion(browser_dist, true, &installed_version);
+    if (!installed_version.IsValid()) {
+      LOG(ERROR) << "No installation of " << browser_dist->GetDisplayName()
+                 << " found for system-level toast.";
+    } else {
+      product.LaunchUserExperiment(setup_exe, installer::REENTRY_SYS_UPDATE,
+                                   true);
     }
   } else if (cmd_line.HasSwitch(installer::switches::kPatch)) {
     const std::string patch_type_str(
         cmd_line.GetSwitchValueASCII(installer::switches::kPatch));
     const base::FilePath input_file(
         cmd_line.GetSwitchValuePath(installer::switches::kInputFile));
     const base::FilePath patch_file(
         cmd_line.GetSwitchValuePath(installer::switches::kPatchFile));
     const base::FilePath output_file(
         cmd_line.GetSwitchValuePath(installer::switches::kOutputFile));
@@ skipping 23 matching lines @@
         cmd_line.GetSwitchValueNative(
             installer::switches::kSetDisplayVersionValue));
     *exit_code = OverwriteDisplayVersions(registry_product, registry_value);
   } else {
     handled = false;
   }
 
   return handled;
 }
 
-// Uninstalls multi-install Chrome Frame if the current operation is a
-// multi-install install or update. The operation is performed directly rather
-// than delegated to the existing install since there is no facility in older
-// versions of setup.exe to uninstall GCF without touching the binaries. The
-// binaries will be uninstalled during later processing if they are not in-use
-// (see UninstallBinariesIfUnused). |original_state| and |installer_state| are
-// updated to reflect the state of the world following the operation.
-void UninstallMultiChromeFrameIfPresent(const base::CommandLine& cmd_line,
-                                        const MasterPreferences& prefs,
-                                        InstallationState* original_state,
-                                        InstallerState* installer_state) {
-  // Early exit if not installing or updating.
-  if (installer_state->operation() == InstallerState::UNINSTALL)
-    return;
-
-  // Early exit if Chrome Frame is not present as multi-install.
-  const ProductState* chrome_frame_state =
-      original_state->GetProductState(installer_state->system_install(),
-                                      BrowserDistribution::CHROME_FRAME);
-  if (!chrome_frame_state || !chrome_frame_state->is_multi_install())
-    return;
-
-  LOG(INFO) << "Uninstalling multi-install Chrome Frame.";
-  installer_state->SetStage(installer::UNINSTALLING_CHROME_FRAME);
-
-  // Uninstall Chrome Frame without touching the multi-install binaries.
-  // Simulate the uninstall as coming from the installed version.
-  const base::CommandLine& uninstall_cmd(
-      chrome_frame_state->uninstall_command());
-  MasterPreferences uninstall_prefs(uninstall_cmd);
-  InstallerState uninstall_state;
-  uninstall_state.Initialize(uninstall_cmd, uninstall_prefs, *original_state);
-  // Post M32, uninstall_prefs and uninstall_state won't have Chrome Frame in
-  // them since they've lost the power to do Chrome Frame installs.
-  const Product* chrome_frame_product = uninstall_state.AddProductFromState(
-      BrowserDistribution::CHROME_FRAME, *chrome_frame_state);
-  if (chrome_frame_product) {
-    // No shared state should be left behind.
-    const bool remove_all = true;
-    // Don't accept no for an answer.
-    const bool force_uninstall = true;
-    installer::InstallStatus uninstall_status =
-        installer::UninstallProduct(*original_state, uninstall_state,
-                                    uninstall_cmd.GetProgram(),
-                                    *chrome_frame_product, remove_all,
-                                    force_uninstall, cmd_line);
-
-    VLOG(1) << "Uninstallation of Chrome Frame returned status "
-            << uninstall_status;
-  } else {
-    LOG(ERROR) << "Chrome Frame not found for uninstall.";
-  }
-
-  // Refresh state for the continuation of the original install/update.
-  original_state->Initialize();
-  installer_state->Initialize(cmd_line, prefs, *original_state);
-}
-
 }  // namespace
 
 namespace installer {
 
 InstallStatus InstallProductsHelper(const InstallationState& original_state,
                                     const base::FilePath& setup_exe,
                                     const base::CommandLine& cmd_line,
                                     const MasterPreferences& prefs,
                                     const InstallerState& installer_state,
                                     base::FilePath* installer_directory,
@@ skipping 100 matching lines @@
   if (!installer_version.get()) {
     LOG(ERROR) << "Did not find any valid version in installer.";
     install_status = INVALID_ARCHIVE;
     installer_state.WriteInstallerResult(install_status,
         IDS_INSTALL_INVALID_ARCHIVE_BASE, NULL);
   } else {
     VLOG(1) << "version to install: " << installer_version->GetString();
     bool proceed_with_installation = true;
 
     if (!IsDowngradeAllowed(prefs)) {
-      uint32_t higher_products = 0;
-      static_assert(
-          sizeof(higher_products) * 8 > BrowserDistribution::NUM_TYPES,
-          "too many distribution types");
-      const Products& products = installer_state.products();
-      for (Products::const_iterator it = products.begin(); it < products.end();
-           ++it) {
-        const Product& product = **it;
-        const ProductState* product_state = original_state.GetProductState(
-            system_install, product.distribution()->GetType());
-        if (product_state != NULL &&
-            (product_state->version().CompareTo(*installer_version) > 0)) {
-          LOG(ERROR) << "Higher version of "
-                     << product.distribution()->GetDisplayName()
-                     << " is already installed.";
-          higher_products |= (1 << product.distribution()->GetType());
-        }
-      }
-
-      if (higher_products != 0) {
-        static_assert(BrowserDistribution::NUM_TYPES == 3,
-                      "add support for new products here");
+      const Product& product = installer_state.product();
+      const ProductState* product_state = original_state.GetProductState(
+          system_install, product.distribution()->GetType());
+      if (product_state != NULL &&
+          (product_state->version().CompareTo(*installer_version) > 0)) {
+        LOG(ERROR) << "Higher version of "
+                   << product.distribution()->GetDisplayName()
+                   << " is already installed.";
         int message_id = IDS_INSTALL_HIGHER_VERSION_BASE;
         proceed_with_installation = false;
         install_status = HIGHER_VERSION_EXISTS;
         installer_state.WriteInstallerResult(install_status, message_id, NULL);
       }
     }
 
     if (proceed_with_installation) {
       base::FilePath prefs_source_path(cmd_line.GetSwitchValueNative(
           switches::kInstallerData));
@@ skipping 15 matching lines @@
           install_status = OS_ERROR;
         } else {
           chrome_exe = installer_state.target_path().Append(kChromeExe);
           quoted_chrome_exe = L"\"" + chrome_exe.value() + L"\"";
           install_msg_base = 0;
         }
       }
 
       installer_state.SetStage(FINISHING);
 
-      // Only do Chrome-specific stuff (like launching the browser) if
-      // Chrome was specifically requested (rather than being upgraded as
-      // part of a multi-install).
-      const Product* chrome_install = prefs.install_chrome() ?
-          installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER) :
-          NULL;
+      const Product& chrome_install = installer_state.product();
 
       bool do_not_register_for_update_launch = false;
-      if (chrome_install) {
-        prefs.GetBool(master_preferences::kDoNotRegisterForUpdateLaunch,
-                      &do_not_register_for_update_launch);
-      } else {
-        do_not_register_for_update_launch = true;  // Never register.
-      }
+      prefs.GetBool(master_preferences::kDoNotRegisterForUpdateLaunch,
+                    &do_not_register_for_update_launch);
 
       bool write_chrome_launch_string =
           (!do_not_register_for_update_launch &&
            install_status != IN_USE_UPDATED);
 
       installer_state.WriteInstallerResult(install_status, install_msg_base,
           write_chrome_launch_string ? &quoted_chrome_exe : NULL);
 
       if (install_status == FIRST_INSTALL_SUCCESS) {
         VLOG(1) << "First install successful.";
-        if (chrome_install) {
-          // We never want to launch Chrome in system level install mode.
-          bool do_not_launch_chrome = false;
-          prefs.GetBool(master_preferences::kDoNotLaunchChrome,
-                        &do_not_launch_chrome);
-          if (!system_install && !do_not_launch_chrome)
-            chrome_install->LaunchChrome(installer_state.target_path());
-        }
+        // We never want to launch Chrome in system level install mode.
+        bool do_not_launch_chrome = false;
+        prefs.GetBool(master_preferences::kDoNotLaunchChrome,
+                      &do_not_launch_chrome);
+        if (!system_install && !do_not_launch_chrome)
+          chrome_install.LaunchChrome(installer_state.target_path());
       } else if ((install_status == NEW_VERSION_UPDATED) ||
                  (install_status == IN_USE_UPDATED)) {
-        const Product* chrome = installer_state.FindProduct(
-            BrowserDistribution::CHROME_BROWSER);
-        if (chrome != NULL) {
-          DCHECK_NE(chrome_exe.value(), base::string16());
-          RemoveChromeLegacyRegistryKeys(chrome->distribution(), chrome_exe);
-        }
+        const Product& chrome = installer_state.product();
+        DCHECK_NE(chrome_exe.value(), base::string16());
+        RemoveChromeLegacyRegistryKeys(chrome.distribution(), chrome_exe);
       }
     }
   }
 
   // There might be an experiment (for upgrade usually) that needs to happen.
   // An experiment's outcome can include chrome's uninstallation. If that is
   // the case we would not do that directly at this point but in another
   // instance of setup.exe
   //
   // There is another way to reach this same function if this is a system
   // level install. See HandleNonInstallCmdLineOptions().
   {
     // If installation failed, use the path to the currently running setup.
     // If installation succeeded, use the path to setup in the installer dir.
     base::FilePath setup_path(setup_exe);
     if (InstallUtil::GetInstallReturnCode(install_status) == 0) {
       setup_path = installer_state.GetInstallerDirectory(*installer_version)
           .Append(setup_path.BaseName());
     }
-    const Products& products = installer_state.products();
-    for (Products::const_iterator it = products.begin(); it < products.end();
-         ++it) {
-      const Product& product = **it;
-      product.LaunchUserExperiment(setup_path, install_status, system_install);
-    }
+    installer_state.product().LaunchUserExperiment(setup_path, install_status,
+                                                   system_install);
   }
 
   // If the installation completed successfully...
   if (InstallUtil::GetInstallReturnCode(install_status) == 0) {
     // Update the DisplayVersion created by an MSI-based install.
     base::FilePath master_preferences_file(
       installer_state.target_path().AppendASCII(
           installer::kDefaultMasterPrefs));
     std::string install_id;
     if (prefs.GetString(installer::master_preferences::kMsiProductId,
                         &install_id)) {
       // A currently active MSI install will have specified the master-
       // preferences file on the command-line that includes the product-id.
       // We must delay the setting of the DisplayVersion until after the
       // grandparent "msiexec" process has exited.
       base::FilePath new_setup =
           installer_state.GetInstallerDirectory(*installer_version)
           .Append(kSetupExe);
       DelayedOverwriteDisplayVersions(
           new_setup, install_id, *installer_version);
     } else {
       // Only when called by the MSI installer do we need to delay setting
       // the DisplayVersion.  In other runs, such as those done by the auto-
       // update action, we set the value immediately.
-      const Product* chrome = installer_state.FindProduct(
-          BrowserDistribution::CHROME_BROWSER);
-      if (chrome != NULL) {
-        // Get the app's MSI Product-ID from an entry in ClientState.
-        base::string16 app_guid = FindMsiProductId(installer_state, chrome);
-        if (!app_guid.empty()) {
-          OverwriteDisplayVersions(app_guid,
-                                   base::UTF8ToUTF16(
-                                       installer_version->GetString()));
-        }
+      const Product& chrome = installer_state.product();
+      // Get the app's MSI Product-ID from an entry in ClientState.
+      base::string16 app_guid = FindMsiProductId(installer_state, chrome);
+      if (!app_guid.empty()) {
+        OverwriteDisplayVersions(
+            app_guid, base::UTF8ToUTF16(installer_version->GetString()));
       }
     }
     // Return the path to the directory containing the newly installed
     // setup.exe and uncompressed archive if the caller requested it.
     if (installer_directory) {
       *installer_directory =
           installer_state.GetInstallerDirectory(*installer_version);
     }
   }
 
@@ skipping 32 matching lines @@
 
   // install_util uses chrome paths.
   chrome::RegisterPathProvider();
 
   const MasterPreferences& prefs = MasterPreferences::ForCurrentProcess();
   installer::InitInstallerLogging(prefs);
 
   const base::CommandLine& cmd_line = *base::CommandLine::ForCurrentProcess();
   VLOG(1) << "Command Line: " << cmd_line.GetCommandLineString();
 
-  VLOG(1) << "multi install is " << prefs.is_multi_install();
   bool system_install = false;
   prefs.GetBool(installer::master_preferences::kSystemLevel, &system_install);
   VLOG(1) << "system install is " << system_install;
 
   InstallationState original_state;
   original_state.Initialize();
 
   InstallerState installer_state;
   installer_state.Initialize(cmd_line, prefs, original_state);
 
@@ skipping 29 matching lines @@
   base::win::ScopedCOMInitializer com_initializer;
   if (!com_initializer.succeeded()) {
     installer_state.WriteInstallerResult(
         installer::OS_ERROR, IDS_INSTALL_OS_ERROR_BASE, NULL);
     return installer::OS_ERROR;
   }
 
   // Some command line options don't work with SxS install/uninstall
   if (InstallUtil::IsChromeSxSProcess()) {
     if (system_install ||
-        prefs.is_multi_install() ||
         cmd_line.HasSwitch(installer::switches::kSelfDestruct) ||
         cmd_line.HasSwitch(installer::switches::kMakeChromeDefault) ||
         cmd_line.HasSwitch(installer::switches::kRegisterChromeBrowser) ||
         cmd_line.HasSwitch(installer::switches::kRemoveChromeRegistration) ||
         cmd_line.HasSwitch(installer::switches::kInactiveUserToast) ||
         cmd_line.HasSwitch(installer::switches::kSystemLevelToast)) {
       return installer::SXS_OPTION_NOT_SUPPORTED;
     }
   }
 
@@ skipping 46 matching lines @@
   std::unique_ptr<installer::SetupSingleton> setup_singleton(
       installer::SetupSingleton::Acquire(cmd_line, prefs, &original_state,
                                          &installer_state));
   if (!setup_singleton) {
     installer_state.WriteInstallerResult(
         installer::SETUP_SINGLETON_ACQUISITION_FAILED,
         IDS_INSTALL_SINGLETON_ACQUISITION_FAILED_BASE, nullptr);
     return installer::SETUP_SINGLETON_ACQUISITION_FAILED;
   }
 
-  UninstallMultiChromeFrameIfPresent(cmd_line, prefs,
-                                     &original_state, &installer_state);
-
   base::FilePath installer_directory;
   installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
   // If --uninstall option is given, uninstall the identified product(s)
   if (is_uninstall) {
     install_status =
         UninstallProducts(original_state, installer_state, setup_exe, cmd_line);
   } else {
     // If --uninstall option is not specified, we assume it is install case.
     install_status =
         InstallProducts(original_state, setup_exe, cmd_line, prefs,
                         &installer_state, &installer_directory);
+    DoLegacyCleanups(installer_state, install_status);
   }
 
   UMA_HISTOGRAM_ENUMERATION("Setup.Install.Result", install_status,
                             installer::MAX_INSTALL_STATUS);
 
   // Dump peak memory usage.
   std::unique_ptr<base::ProcessMetrics> process_metrics(
       base::ProcessMetrics::CreateProcessMetrics(
           base::GetCurrentProcessHandle()));
   UMA_HISTOGRAM_MEMORY_KB("Setup.Install.PeakPagefileUsage",
@@ skipping 11 matching lines @@
     // Note that we allow the status installer::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
   }
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }