Remove multi-install from chrome/installer/setup.

chrome/installer/setup/install_worker.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.
 //
 // This file contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <windows.h>  // NOLINT
 #include <atlsecurity.h>
 #include <oaidl.h>
 #include <shlobj.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <time.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
-#include "base/macros.h"
-#include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
-#include "base/win/windows_version.h"
-#include "chrome/common/chrome_constants.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/installer/setup/app_launcher_installer.h"
-#include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/installer_state.h"
 #include "chrome/installer/setup/persistent_histogram_storage.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/app_registration_data.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/callback_work_item.h"
 #include "chrome/installer/util/conditional_work_item_list.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/firewall_manager_win.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/l10n_string_util.h"
+#include "chrome/installer/util/non_updating_app_registration_data.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/shell_util.h"
+#include "chrome/installer/util/updating_app_registration_data.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 
 using base::ASCIIToUTF16;
 using base::win::RegKey;
 
 namespace installer {
 
 namespace {
 
-// Although the UUID of the ChromeFrame class is used for the "current" value,
-// this is done only as a convenience; there is no need for the GUID of the Low
-// Rights policies to match the ChromeFrame class's GUID.  Hence, it is safe to
-// use this completely unrelated GUID for the "old" policies.
-const wchar_t kIELowRightsPolicyOldGuid[] =
-    L"{6C288DD7-76FB-4721-B628-56FAC252E199}";
-
-const wchar_t kElevationPolicyKeyPath[] =
-    L"SOFTWARE\\Microsoft\\Internet Explorer\\Low Rights\\ElevationPolicy\\";
-
-void GetOldIELowRightsElevationPolicyKeyPath(base::string16* key_path) {
-  key_path->assign(kElevationPolicyKeyPath,
-                   arraysize(kElevationPolicyKeyPath) - 1);
-  key_path->append(kIELowRightsPolicyOldGuid,
-                   arraysize(kIELowRightsPolicyOldGuid)- 1);
-}
-
-// Local helper to call AddRegisterComDllWorkItems for all DLLs in a set of
-// products managed by a given package.
-// |old_version| can be NULL to indicate no Chrome is currently installed.
-void AddRegisterComDllWorkItemsForPackage(const InstallerState& installer_state,
-                                          const base::Version* old_version,
-                                          const base::Version& new_version,
-                                          WorkItemList* work_item_list) {
-  // First collect the list of DLLs to be registered from each product.
-  std::vector<base::FilePath> com_dll_list;
-  installer_state.AddComDllList(&com_dll_list);
-
-  // Then, if we got some, attempt to unregister the DLLs from the old
-  // version directory and then re-register them in the new one.
-  // Note that if we are migrating the install directory then we will not
-  // successfully unregister the old DLLs.
-  // TODO(robertshield): See whether we need to fix the migration case.
-  // TODO(robertshield): If we ever remove a DLL from a product, this will
-  // not unregister it on update. We should build the unregistration list from
-  // saved state instead of assuming it is the same as the registration list.
-  if (!com_dll_list.empty()) {
-    if (old_version) {
-      base::FilePath old_dll_path(installer_state.target_path().AppendASCII(
-          old_version->GetString()));
-
-      installer::AddRegisterComDllWorkItems(old_dll_path,
-                                            com_dll_list,
-                                            installer_state.system_install(),
-                                            false,  // Unregister
-                                            true,   // May fail
-                                            work_item_list);
-    }
-
-    base::FilePath dll_path(installer_state.target_path().AppendASCII(
-        new_version.GetString()));
-    installer::AddRegisterComDllWorkItems(dll_path,
-                                          com_dll_list,
-                                          installer_state.system_install(),
-                                          true,   // Register
-                                          false,  // Must succeed.
-                                          work_item_list);
-  }
-}
-
 void AddInstallerCopyTasks(const InstallerState& installer_state,
                            const base::FilePath& setup_path,
                            const base::FilePath& archive_path,
                            const base::FilePath& temp_path,
                            const base::Version& new_version,
                            WorkItemList* install_list) {
   DCHECK(install_list);
   base::FilePath installer_dir(
       installer_state.GetInstallerDirectory(new_version));
   install_list->AddCreateDirWorkItem(installer_dir);
@@ skipping 90 matching lines @@
                  installer_state.target_path().Append(kChromeExe),
                  is_new_install));
 }
 
 void AddProductSpecificWorkItems(const InstallationState& original_state,
                                  const InstallerState& installer_state,
                                  const base::FilePath& setup_path,
                                  const base::Version& new_version,
                                  const base::Version* current_version,
                                  bool add_language_identifier,
                                  WorkItemList* list) {

[robertshield, 2017/01/04 14:23:18]

Do we still need this function at all? Since we're moving to a single-product
model, could the code below be inlined where AddProductSpecificWorkItems is now
called?

[grt (UTC plus 2), 2017/01/05 13:08:29]

Nope; removed.

-  const Products& products = installer_state.products();
-  for (Products::const_iterator it = products.begin(); it < products.end();
-       ++it) {
-    const Product& p = **it;
-    if (p.is_chrome()) {
-      AddOsUpgradeWorkItems(installer_state, setup_path, new_version, p,
-                            list);
-      AddFirewallRulesWorkItems(installer_state, p.distribution(),
-                                current_version == nullptr, list);
+  const Product& p = installer_state.product();
+  AddOsUpgradeWorkItems(installer_state, setup_path, new_version, p, list);
+  AddFirewallRulesWorkItems(installer_state, p.distribution(),
+                            current_version == nullptr, list);
 
-#if defined(GOOGLE_CHROME_BUILD)
-      if (!InstallUtil::IsChromeSxSProcess()) {
-        // Remove the app launcher key as it has been deprecated.
-        RemoveAppLauncherVersionKey(installer_state.root_key());
-      }
-#endif  // GOOGLE_CHROME_BUILD
-      InstallUtil::AddUpdateDowngradeVersionItem(
-          installer_state.system_install(), current_version, new_version,
-          p.distribution(), list);
-    }
-    if (p.is_chrome_binaries())
-      AddQuickEnableChromeFrameWorkItems(installer_state, list);
-  }
+  InstallUtil::AddUpdateDowngradeVersionItem(installer_state.system_install(),
+                                             current_version, new_version,
+                                             p.distribution(), list);
 }
 
 // This is called when an MSI installation is run. It may be that a user is
 // attempting to install the MSI on top of a non-MSI managed installation. If
 // so, try and remove any existing "Add/Remove Programs" entry, as we want the
 // uninstall to be managed entirely by the MSI machinery (accessible via the
 // Add/Remove programs dialog).
 void AddDeleteUninstallEntryForMSIWorkItems(
     const InstallerState& installer_state,
     const Product& product,
@@ skipping 39 matching lines @@
       delete_old_archive_work_item->set_rollback_enabled(false);
     }
   }
 
   // Delete any new_chrome.exe if present (we will end up creating a new one
   // if required) and then copy chrome.exe
   base::FilePath new_chrome_exe(target_path.Append(installer::kChromeNewExe));
 
   install_list->AddDeleteTreeWorkItem(new_chrome_exe, temp_path);
 
-  // TODO(grt): Remove this check in M35.
-  if (installer_state.IsChromeFrameRunning(original_state)) {
-    VLOG(1) << "Chrome Frame in use. Copying to new_chrome.exe";
-    install_list->AddCopyTreeWorkItem(
-        src_path.Append(installer::kChromeExe).value(),
-        new_chrome_exe.value(),
-        temp_path.value(),
-        WorkItem::ALWAYS);
-  } else {
-    install_list->AddCopyTreeWorkItem(
-        src_path.Append(installer::kChromeExe).value(),
-        target_path.Append(installer::kChromeExe).value(),
-        temp_path.value(),
-        WorkItem::NEW_NAME_IF_IN_USE,
-        new_chrome_exe.value());
-  }
+  install_list->AddCopyTreeWorkItem(
+      src_path.Append(installer::kChromeExe).value(),
+      target_path.Append(installer::kChromeExe).value(), temp_path.value(),
+      WorkItem::NEW_NAME_IF_IN_USE, new_chrome_exe.value());
 
   // Install kVisualElementsManifest if it is present in |src_path|. No need to
   // make this a conditional work item as if the file is not there now, it will
   // never be.
   if (base::PathExists(
           src_path.Append(installer::kVisualElementsManifest))) {
     install_list->AddMoveTreeWorkItem(
         src_path.Append(installer::kVisualElementsManifest).value(),
         target_path.Append(installer::kVisualElementsManifest).value(),
         temp_path.value(),
@@ skipping 26 matching lines @@
       ->AddDeleteTreeWorkItem(target_path.Append(installer::kChromeOldExe),
                               temp_path)
       ->set_best_effort(true);
 }
 
 // Adds work items to remove COM registration for |product|'s deprecated
 // DelegateExecute verb handler.
 void AddCleanupDelegateExecuteWorkItems(const InstallerState& installer_state,
                                         const Product& product,
                                         WorkItemList* list) {
-  if (product.is_chrome()) {
-    VLOG(1) << "Adding unregistration items for DelegateExecute verb handler.";
-    const base::string16 handler_class_uuid =
-        product.distribution()->GetCommandExecuteImplClsid();
-    DCHECK(!handler_class_uuid.empty());
+  VLOG(1) << "Adding unregistration items for DelegateExecute verb handler.";
+  const base::string16 handler_class_uuid =
+      product.distribution()->GetCommandExecuteImplClsid();
+  DCHECK(!handler_class_uuid.empty());
 
-    const HKEY root = installer_state.root_key();
-    base::string16 delegate_execute_path(L"Software\\Classes\\CLSID\\");
-    delegate_execute_path.append(handler_class_uuid);
-    // Delete both 64 and 32 keys to handle 32->64 or 64->32 migration.
-    list->AddDeleteRegKeyWorkItem(root, delegate_execute_path, KEY_WOW64_32KEY);
-    list->AddDeleteRegKeyWorkItem(root, delegate_execute_path, KEY_WOW64_64KEY);
-  }
+  const HKEY root = installer_state.root_key();
+  base::string16 delegate_execute_path(L"Software\\Classes\\CLSID\\");
+  delegate_execute_path.append(handler_class_uuid);
+  // Delete both 64 and 32 keys to handle 32->64 or 64->32 migration.
+  list->AddDeleteRegKeyWorkItem(root, delegate_execute_path, KEY_WOW64_32KEY);
+  list->AddDeleteRegKeyWorkItem(root, delegate_execute_path, KEY_WOW64_64KEY);
 }
 
 // Add to the ACL of an object on disk. This follows the method from MSDN:
 // https://msdn.microsoft.com/en-us/library/windows/desktop/aa379283.aspx
 // This is done using explicit flags rather than the "security string" format
 // because strings do not necessarily read what is written which makes it
 // difficult to de-dup. Working with the binary format is always exact and the
 // system libraries will properly ignore duplicate ACL entries.
 bool AddAclToPath(const base::FilePath& path,
                   const CSid& trustee,
@@ skipping 31 matching lines @@
 
   // Attach the updated ACL as the object's DACL.
   if (!ATL::AtlSetDacl(path.value().c_str(), SE_FILE_OBJECT, dacl)) {
     DPLOG(ERROR) << "Failed setting DACL for path \"" << path.value() << "\"";
     return false;
   }
 
   return true;
 }
 
+// Migrates the usagestats value from the binaries to Chrome when migrating
+// multi-install Chrome to single-install.
+void AddMigrateUsageStatsWorkItems(const InstallationState& original_state,
+                                   const InstallerState& installer_state,
+                                   WorkItemList* install_list) {
+  // This operation doesn't apply to SxS Chrome.
+  if (InstallUtil::IsChromeSxSProcess())
+    return;
+
+  // Bail out if an existing multi-install Chrome is not being migrated to
+  // single-install.
+  if (!installer_state.is_migrating_to_single()) {
+    VLOG(1) << "No multi-install Chrome found to migrate to single-install.";
+    return;
+  }
+
+  const ProductState* binaries_state = original_state.GetProductState(
+      installer_state.system_install(), BrowserDistribution::CHROME_BINARIES);
+
+  // There is nothing to be done if the binaries do not have stats.
+  DWORD usagestats = 0;
+  if (!binaries_state || !binaries_state->GetUsageStats(&usagestats)) {
+    VLOG(1) << "No usagestats value found to migrate to single-install.";
+    return;
+  }
+
+  VLOG(1) << "Migrating usagestats value from multi-install to single-install.";
+
+  // Write the value that was read to Chrome's ClientState key.
+  install_list->AddSetRegValueWorkItem(
+      installer_state.root_key(),
+      installer_state.product().distribution()->GetStateKey(), KEY_WOW64_32KEY,
+      google_update::kRegUsageStatsField, usagestats, true);
+}
+
 }  // namespace
 
 // This method adds work items to create (or update) Chrome uninstall entry in
 // either the Control Panel->Add/Remove Programs list or in the Omaha client
 // state key if running under an MSI installer.
 void AddUninstallShortcutWorkItems(const InstallerState& installer_state,
                                    const base::FilePath& setup_path,
                                    const base::Version& new_version,
                                    const Product& product,
                                    WorkItemList* install_list) {
@@ skipping 172 matching lines @@
                                  false);  // do not overwrite language
   }
   list->AddSetRegValueWorkItem(root,
                                version_key,
                                KEY_WOW64_32KEY,
                                google_update::kRegVersionField,
                                ASCIIToUTF16(new_version.GetString()),
                                true);  // overwrite version
 }
 
-// Mirror oeminstall the first time anything is installed multi.  There is no
-// need to update the value on future install/update runs since this value never
-// changes.  Note that the value is removed by Google Update after EULA
-// acceptance is processed.
-void AddOemInstallWorkItems(const InstallationState& original_state,
-                            const InstallerState& installer_state,
-                            WorkItemList* install_list) {
-  DCHECK(installer_state.is_multi_install());
-  const bool system_install = installer_state.system_install();
-  if (!original_state.GetProductState(system_install,
-                                      BrowserDistribution::CHROME_BINARIES)) {
-    const HKEY root_key = installer_state.root_key();
-    base::string16 multi_key(
-        installer_state.multi_package_binaries_distribution()->GetStateKey());
-
-    // Copy the value from Chrome unless Chrome isn't installed or being
-    // installed.
-    BrowserDistribution::Type source_type;
-    if (installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER)) {
-      source_type = BrowserDistribution::CHROME_BROWSER;
-    } else if (!installer_state.products().empty()) {
-      // Pick a product, any product.
-      source_type = installer_state.products()[0]->distribution()->GetType();
-    } else {
-      // Nothing is being installed?  Entirely unexpected, so do no harm.
-      LOG(ERROR) << "No products found in AddOemInstallWorkItems";
-      return;
-    }
-    const ProductState* source_product =
-        original_state.GetNonVersionedProductState(system_install, source_type);
-
-    base::string16 oem_install;
-    if (source_product->GetOemInstall(&oem_install)) {
-      VLOG(1) << "Mirroring oeminstall=\"" << oem_install << "\" from "
-              << BrowserDistribution::GetSpecificDistribution(source_type)->
-                     GetDisplayName();
-      install_list->AddCreateRegKeyWorkItem(
-          root_key, multi_key, KEY_WOW64_32KEY);
-      // Always overwrite an old value.
-      install_list->AddSetRegValueWorkItem(root_key,
-                                           multi_key,
-                                           KEY_WOW64_32KEY,
-                                           google_update::kRegOemInstallField,
-                                           oem_install,
-                                           true);
-    } else {
-      // Clear any old value.
-      install_list->AddDeleteRegValueWorkItem(
-          root_key,
-          multi_key,
-          KEY_WOW64_32KEY,
-          google_update::kRegOemInstallField);
-    }
-  }
-}
-
-// Mirror eulaaccepted the first time anything is installed multi.  There is no
-// need to update the value on future install/update runs since
-// GoogleUpdateSettings::SetEULAConsent will modify the value for both the
-// relevant product and for the binaries.
-void AddEulaAcceptedWorkItems(const InstallationState& original_state,
-                              const InstallerState& installer_state,
-                              WorkItemList* install_list) {
-  DCHECK(installer_state.is_multi_install());
-  const bool system_install = installer_state.system_install();
-  if (!original_state.GetProductState(system_install,
-                                      BrowserDistribution::CHROME_BINARIES)) {
-    const HKEY root_key = installer_state.root_key();
-    base::string16 multi_key(
-        installer_state.multi_package_binaries_distribution()->GetStateKey());
-
-    // Copy the value from the product with the greatest value.
-    bool have_eula_accepted = false;
-    BrowserDistribution::Type product_type = BrowserDistribution::NUM_TYPES;
-    DWORD eula_accepted = 0;
-    const Products& products = installer_state.products();
-    for (Products::const_iterator it = products.begin(); it < products.end();
-         ++it) {
-      const Product& product = **it;
-      if (product.is_chrome_binaries())
-        continue;
-      DWORD dword_value = 0;
-      BrowserDistribution::Type this_type = product.distribution()->GetType();
-      const ProductState* product_state =
-          original_state.GetNonVersionedProductState(
-              system_install, this_type);
-      if (product_state->GetEulaAccepted(&dword_value) &&
-          (!have_eula_accepted || dword_value > eula_accepted)) {
-        have_eula_accepted = true;
-        eula_accepted = dword_value;
-        product_type = this_type;
-      }
-    }
-
-    if (have_eula_accepted) {
-      VLOG(1) << "Mirroring eulaaccepted=" << eula_accepted << " from "
-              << BrowserDistribution::GetSpecificDistribution(product_type)->
-                     GetDisplayName();
-      install_list->AddCreateRegKeyWorkItem(
-          root_key, multi_key, KEY_WOW64_32KEY);
-      install_list->AddSetRegValueWorkItem(root_key,
-                                           multi_key,
-                                           KEY_WOW64_32KEY,
-                                           google_update::kRegEULAAceptedField,
-                                           eula_accepted,
-                                           true);
-    } else {
-      // Clear any old value.
-      install_list->AddDeleteRegValueWorkItem(
-          root_key,
-          multi_key,
-          KEY_WOW64_32KEY,
-          google_update::kRegEULAAceptedField);
-    }
-  }
-}
-
-// Adds work items that make registry adjustments for Google Update.
-void AddGoogleUpdateWorkItems(const InstallationState& original_state,
-                              const InstallerState& installer_state,
-                              WorkItemList* install_list) {
-  // Is a multi-install product being installed or over-installed?
-  if (installer_state.operation() != InstallerState::MULTI_INSTALL &&
-      installer_state.operation() != InstallerState::MULTI_UPDATE) {
-    VLOG(1) << "AddGoogleUpdateWorkItems noop: " << installer_state.operation();
-    return;
-  }
-
-  const bool system_install = installer_state.system_install();
-  const HKEY root_key = installer_state.root_key();
-  base::string16 multi_key(
-      installer_state.multi_package_binaries_distribution()->GetStateKey());
-
-  // For system-level installs, make sure the ClientStateMedium key for the
-  // binaries exists.
-  if (system_install) {
-    install_list->AddCreateRegKeyWorkItem(
-        root_key,
-        installer_state.multi_package_binaries_distribution()
-            ->GetStateMediumKey()
-            .c_str(),
-        KEY_WOW64_32KEY);
-  }
-
-  // Creating the ClientState key for binaries, if we're migrating to multi then
-  // copy over Chrome's brand code if it has one.
-  if (installer_state.state_type() != BrowserDistribution::CHROME_BINARIES) {
-    const ProductState* chrome_product_state =
-        original_state.GetNonVersionedProductState(
-            system_install, BrowserDistribution::CHROME_BROWSER);
-
-    const base::string16& brand(chrome_product_state->brand());
-    if (!brand.empty()) {
-      install_list->AddCreateRegKeyWorkItem(
-          root_key, multi_key, KEY_WOW64_32KEY);
-      // Write Chrome's brand code to the multi key. Never overwrite the value
-      // if one is already present (although this shouldn't happen).
-      install_list->AddSetRegValueWorkItem(root_key,
-                                           multi_key,
-                                           KEY_WOW64_32KEY,
-                                           google_update::kRegBrandField,
-                                           brand,
-                                           false);
-    }
-  }
-
-  AddOemInstallWorkItems(original_state, installer_state, install_list);
-  AddEulaAcceptedWorkItems(original_state, installer_state, install_list);
-  AddUsageStatsWorkItems(original_state, installer_state, install_list);
-
-  // TODO(grt): check for other keys/values we should put in the package's
-  // ClientState and/or Clients key.
-}
-
-void AddUsageStatsWorkItems(const InstallationState& original_state,
-                            const InstallerState& installer_state,
-                            WorkItemList* install_list) {
-  DCHECK(installer_state.operation() == InstallerState::MULTI_INSTALL ||
-         installer_state.operation() == InstallerState::MULTI_UPDATE);
-
-  HKEY root_key = installer_state.root_key();
-  bool value_found = false;
-  DWORD usagestats = 0;
-  const Products& products = installer_state.products();
-
-  // Search for an existing usagestats value for any product.
-  for (Products::const_iterator scan = products.begin(), end = products.end();
-       !value_found && scan != end; ++scan) {
-    if ((*scan)->is_chrome_binaries())
-      continue;
-    BrowserDistribution* dist = (*scan)->distribution();
-    const ProductState* product_state =
-        original_state.GetNonVersionedProductState(
-            installer_state.system_install(), dist->GetType());
-    value_found = product_state->GetUsageStats(&usagestats);
-  }
-
-  // If a value was found, write it in the appropriate location for the
-  // binaries and remove all values from the products.
-  if (value_found) {
-    base::string16 state_key(
-        installer_state.multi_package_binaries_distribution()->GetStateKey());
-    install_list->AddCreateRegKeyWorkItem(root_key, state_key, KEY_WOW64_32KEY);
-    // Overwrite any existing value so that overinstalls (where Omaha writes a
-    // new value into a product's state key) pick up the correct value.
-    install_list->AddSetRegValueWorkItem(root_key,
-                                         state_key,
-                                         KEY_WOW64_32KEY,
-                                         google_update::kRegUsageStatsField,
-                                         usagestats,
-                                         true);
-
-    for (Products::const_iterator scan = products.begin(), end = products.end();
-         scan != end; ++scan) {
-      if ((*scan)->is_chrome_binaries())
-        continue;
-      BrowserDistribution* dist = (*scan)->distribution();
-      if (installer_state.system_install()) {
-        install_list->AddDeleteRegValueWorkItem(
-            root_key,
-            dist->GetStateMediumKey(),
-            KEY_WOW64_32KEY,
-            google_update::kRegUsageStatsField);
-        // Previous versions of Chrome also wrote a value in HKCU even for
-        // system-level installs, so clean that up.
-        install_list->AddDeleteRegValueWorkItem(
-            HKEY_CURRENT_USER,
-            dist->GetStateKey(),
-            KEY_WOW64_32KEY,
-            google_update::kRegUsageStatsField);
-      }
-      install_list->AddDeleteRegValueWorkItem(
-          root_key,
-          dist->GetStateKey(),
-          KEY_WOW64_32KEY,
-          google_update::kRegUsageStatsField);
-    }
-  }
-}
-
-// Migrates the usagestats value from the binaries to Chrome when migrating
-// multi-install Chrome to single-install.
-void AddMigrateUsageStatesWorkItems(const InstallationState& original_state,
-                                    const InstallerState& installer_state,
-                                    WorkItemList* install_list) {
-  // Ensure that a non-multi install or update is being processed (i.e.,
-  // no "--multi-install" on the command line).
-  if (installer_state.is_multi_install())
-    return;
-
-  // This operation doesn't apply to SxS Chrome.
-  if (InstallUtil::IsChromeSxSProcess())
-    return;
-
-  // Ensure that Chrome is the product being installed or updated (there are no
-  // other products, so it is especially unexpected for this to fail).
-  const Product* chrome_product =
-      installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER);
-  if (!chrome_product) {
-    LOG(DFATAL) << "Not operating on Chrome while migrating to single-install.";
-    return;
-  }
-
-  // Bail out if an existing multi-install Chrome is not being migrated to
-  // single-install.
-  if (!installer_state.is_migrating_to_single()) {
-    VLOG(1) << "No multi-install Chrome found to migrate to single-install.";
-    return;
-  }
-
-  const ProductState* binaries_state = original_state.GetProductState(
-      installer_state.system_install(),
-      BrowserDistribution::CHROME_BINARIES);
-
-  // There is nothing to be done if the binaries do not have stats.
-  DWORD usagestats = 0;
-  if (!binaries_state || !binaries_state->GetUsageStats(&usagestats)) {
-    VLOG(1) << "No usagestats value found to migrate to single-install.";
-    return;
-  }
-
-  VLOG(1) << "Migrating usagestats value from multi-install to single-install.";
-
-  // Write the value that was read to Chrome's ClientState key.
-  install_list->AddSetRegValueWorkItem(
-      installer_state.root_key(),
-      chrome_product->distribution()->GetStateKey(),
-      KEY_WOW64_32KEY,
-      google_update::kRegUsageStatsField,
-      usagestats,
-      true);
-}
-
 bool AppendPostInstallTasks(const InstallerState& installer_state,
                             const base::FilePath& setup_path,
                             const base::Version* current_version,
                             const base::Version& new_version,
                             WorkItemList* post_install_task_list) {
   DCHECK(post_install_task_list);
 
   HKEY root = installer_state.root_key();
-  const Products& products = installer_state.products();
   base::FilePath new_chrome_exe(
       installer_state.target_path().Append(installer::kChromeNewExe));
 
   // Append work items that will only be executed if this was an update.
   // We update the 'opv' value with the current version that is active,
   // the 'cpv' value with the critical update version (if present), and the
   // 'cmd' value with the rename command to run.
   {
     std::unique_ptr<WorkItemList> in_use_update_work_items(
         WorkItem::CreateConditionalWorkItemList(
             new ConditionRunIfFileExists(new_chrome_exe)));
     in_use_update_work_items->set_log_message("InUseUpdateWorkItemList");
 
     // |critical_version| will be valid only if this in-use update includes a
     // version considered critical relative to the version being updated.
     base::Version critical_version(installer_state.DetermineCriticalVersion(
         current_version, new_version));
     base::FilePath installer_path(
         installer_state.GetInstallerDirectory(new_version).Append(
             setup_path.BaseName()));
 
     base::CommandLine rename(installer_path);
     rename.AppendSwitch(switches::kRenameChromeExe);
     if (installer_state.system_install())
       rename.AppendSwitch(switches::kSystemLevel);
 
     if (installer_state.verbose_logging())
       rename.AppendSwitch(switches::kVerboseLogging);
 
-    base::string16 version_key;
-    for (size_t i = 0; i < products.size(); ++i) {
-      BrowserDistribution* dist = products[i]->distribution();
-      version_key = dist->GetVersionKey();
+    BrowserDistribution* dist = installer_state.product().distribution();
+    const base::string16 version_key = dist->GetVersionKey();
 
-      if (current_version) {
-        in_use_update_work_items->AddSetRegValueWorkItem(
-            root,
-            version_key,
-            KEY_WOW64_32KEY,
-            google_update::kRegOldVersionField,
-            ASCIIToUTF16(current_version->GetString()),
-            true);
-      }
-      if (critical_version.IsValid()) {
-        in_use_update_work_items->AddSetRegValueWorkItem(
-            root,
-            version_key,
-            KEY_WOW64_32KEY,
-            google_update::kRegCriticalVersionField,
-            ASCIIToUTF16(critical_version.GetString()),
-            true);
-      } else {
-        in_use_update_work_items->AddDeleteRegValueWorkItem(
-            root,
-            version_key,
-            KEY_WOW64_32KEY,
-            google_update::kRegCriticalVersionField);
-      }
+    if (current_version) {
+      in_use_update_work_items->AddSetRegValueWorkItem(
+          root, version_key, KEY_WOW64_32KEY,
+          google_update::kRegOldVersionField,
+          ASCIIToUTF16(current_version->GetString()), true);
+    }
+    if (critical_version.IsValid()) {
+      in_use_update_work_items->AddSetRegValueWorkItem(
+          root, version_key, KEY_WOW64_32KEY,
+          google_update::kRegCriticalVersionField,
+          ASCIIToUTF16(critical_version.GetString()), true);
+    } else {
+      in_use_update_work_items->AddDeleteRegValueWorkItem(
+          root, version_key, KEY_WOW64_32KEY,
+          google_update::kRegCriticalVersionField);
+    }
 
-      // Adding this registry entry for all products (but the binaries) is
-      // overkill. However, as it stands, we don't have a way to know which
-      // product will check the key and run the command, so we add it for all.
-      // The first to run it will perform the operation and clean up the other
-      // values.
-      if (dist->GetType() != BrowserDistribution::CHROME_BINARIES) {
-        base::CommandLine product_rename_cmd(rename);
-        products[i]->AppendRenameFlags(&product_rename_cmd);
-        in_use_update_work_items->AddSetRegValueWorkItem(
-            root,
-            version_key,
-            KEY_WOW64_32KEY,
-            google_update::kRegRenameCmdField,
-            product_rename_cmd.GetCommandLineString(),
-            true);
-      }
-    }
+    // Append the distribution-specific flags to the command line (e.g.,
+    // "--chrome-sxs" for SxS/canary).
+    base::CommandLine product_rename_cmd(rename);
+    installer_state.product().AppendRenameFlags(&product_rename_cmd);
+    in_use_update_work_items->AddSetRegValueWorkItem(
+        root, version_key, KEY_WOW64_32KEY, google_update::kRegRenameCmdField,
+        product_rename_cmd.GetCommandLineString(), true);
 
     post_install_task_list->AddWorkItem(in_use_update_work_items.release());
   }
 
   // Append work items that will be executed if this was NOT an in-use update.
   {
     std::unique_ptr<WorkItemList> regular_update_work_items(
         WorkItem::CreateConditionalWorkItemList(
             new Not(new ConditionRunIfFileExists(new_chrome_exe))));
     regular_update_work_items->set_log_message("RegularUpdateWorkItemList");
 
     // Since this was not an in-use-update, delete 'opv', 'cpv', and 'cmd' keys.
-    for (size_t i = 0; i < products.size(); ++i) {
-      BrowserDistribution* dist = products[i]->distribution();
-      base::string16 version_key(dist->GetVersionKey());
-      regular_update_work_items->AddDeleteRegValueWorkItem(
-          root,
-          version_key,
-          KEY_WOW64_32KEY,
-          google_update::kRegOldVersionField);
-      regular_update_work_items->AddDeleteRegValueWorkItem(
-          root,
-          version_key,
-          KEY_WOW64_32KEY,
-          google_update::kRegCriticalVersionField);
-      regular_update_work_items->AddDeleteRegValueWorkItem(
-          root,
-          version_key,
-          KEY_WOW64_32KEY,
-          google_update::kRegRenameCmdField);
-    }
+    BrowserDistribution* dist = installer_state.product().distribution();
+    const base::string16 version_key(dist->GetVersionKey());
+    regular_update_work_items->AddDeleteRegValueWorkItem(
+        root, version_key, KEY_WOW64_32KEY, google_update::kRegOldVersionField);
+    regular_update_work_items->AddDeleteRegValueWorkItem(
+        root, version_key, KEY_WOW64_32KEY,
+        google_update::kRegCriticalVersionField);
+    regular_update_work_items->AddDeleteRegValueWorkItem(
+        root, version_key, KEY_WOW64_32KEY, google_update::kRegRenameCmdField);
 
     post_install_task_list->AddWorkItem(regular_update_work_items.release());
   }
 
-  AddRegisterComDllWorkItemsForPackage(installer_state, current_version,
-                                       new_version, post_install_task_list);
-
   // If we're told that we're an MSI install, make sure to set the marker
   // in the client state key so that future updates do the right thing.
   if (installer_state.is_msi()) {
-    for (size_t i = 0; i < products.size(); ++i) {
-      const Product* product = products[i];
-      AddSetMsiMarkerWorkItem(installer_state, product->distribution(), true,
-                              post_install_task_list);
+    const Product& product = installer_state.product();
+    AddSetMsiMarkerWorkItem(installer_state, product.distribution(), true,
+                            post_install_task_list);
 
-      // We want MSI installs to take over the Add/Remove Programs entry. Make a
-      // best-effort attempt to delete any entry left over from previous non-MSI
-      // installations for the same type of install (system or per user).
-      if (product->ShouldCreateUninstallEntry()) {
-        AddDeleteUninstallEntryForMSIWorkItems(installer_state, *product,
-                                               post_install_task_list);
-      }
+    // We want MSI installs to take over the Add/Remove Programs entry. Make a
+    // best-effort attempt to delete any entry left over from previous non-MSI
+    // installations for the same type of install (system or per user).
+    if (product.ShouldCreateUninstallEntry()) {
+      AddDeleteUninstallEntryForMSIWorkItems(installer_state, product,
+                                             post_install_task_list);
     }
   }
 
   return true;
 }
 
 void AddInstallWorkItems(const InstallationState& original_state,
                          const InstallerState& installer_state,
                          const base::FilePath& setup_path,
                          const base::FilePath& archive_path,
@@ skipping 24 matching lines @@
               return AddAclToPath(histogram_storage_dir,
                                   ATL::Sids::AuthenticatedUser(),
                                   FILE_GENERIC_READ | FILE_DELETE_CHILD,
                                   CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE);
             },
             histogram_storage_dir));
     add_acl_to_histogram_storage_dir_work_item->set_best_effort(true);
     add_acl_to_histogram_storage_dir_work_item->set_rollback_enabled(false);
   }
 
-  if (installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER) ||
-      installer_state.FindProduct(BrowserDistribution::CHROME_BINARIES)) {
-    AddChromeWorkItems(original_state,
-                       installer_state,
-                       setup_path,
-                       archive_path,
-                       src_path,
-                       temp_path,
-                       current_version,
-                       new_version,
-                       install_list);
-  }
-
-#if defined(GOOGLE_CHROME_BUILD)
-  // For Chrome, unconditionally remove the legacy app_host.exe.
-  if (!InstallUtil::IsChromeSxSProcess())
-    AddRemoveLegacyAppHostExeWorkItems(target_path, temp_path, install_list);
-#endif  // GOOGLE_CHROME_BUILD
+  AddChromeWorkItems(original_state, installer_state, setup_path, archive_path,
+                     src_path, temp_path, current_version, new_version,
+                     install_list);
 
   // Copy installer in install directory
   AddInstallerCopyTasks(installer_state, setup_path, archive_path, temp_path,
                         new_version, install_list);
 
   const HKEY root = installer_state.root_key();
   // Only set "lang" for user-level installs since for system-level, the install
   // language may not be related to a given user's runtime language.
   const bool add_language_identifier = !installer_state.system_install();
 
-  const Products& products = installer_state.products();
-  for (Products::const_iterator it = products.begin(); it < products.end();
-       ++it) {
-    const Product& product = **it;
+  const Product& product = installer_state.product();
+  AddUninstallShortcutWorkItems(installer_state, setup_path, new_version,
+                                product, install_list);
 
-    AddUninstallShortcutWorkItems(installer_state, setup_path, new_version,
-                                  product, install_list);
+  BrowserDistribution* dist = product.distribution();
+  AddVersionKeyWorkItems(root, dist->GetVersionKey(), dist->GetDisplayName(),
+                         new_version, add_language_identifier, install_list);
 
-    BrowserDistribution* dist = product.distribution();
-    AddVersionKeyWorkItems(root,
-                           dist->GetVersionKey(),
-                           dist->GetDisplayName(),
-                           new_version,
-                           add_language_identifier,
-                           install_list);
+  AddCleanupDelegateExecuteWorkItems(installer_state, product, install_list);
+  AddCleanupDeprecatedPerUserRegistrationsWorkItems(product, install_list);
 
-    AddCleanupDelegateExecuteWorkItems(installer_state, product, install_list);
-    AddCleanupDeprecatedPerUserRegistrationsWorkItems(product, install_list);
-
-    AddActiveSetupWorkItems(installer_state, new_version, product,
-                            install_list);
-  }
-
-  // Ensure that the Clients key for the binaries is gone for single installs
-  // (but not for SxS Chrome).
-  if (!installer_state.is_multi_install() &&
-      !InstallUtil::IsChromeSxSProcess()) {
-    BrowserDistribution* binaries_dist =
-        BrowserDistribution::GetSpecificDistribution(
-            BrowserDistribution::CHROME_BINARIES);
-    install_list->AddDeleteRegKeyWorkItem(root,
-                                          binaries_dist->GetVersionKey(),
-                                          KEY_WOW64_32KEY);
-  }
-
-#if defined(GOOGLE_CHROME_BUILD)
-  if (!InstallUtil::IsChromeSxSProcess())
-    AddRemoveLegacyAppCommandsWorkItems(installer_state, install_list);
-#endif  // GOOGLE_CHROME_BUILD
+  AddActiveSetupWorkItems(installer_state, new_version, product, install_list);
 
   // Add any remaining work items that involve special settings for
   // each product.
   AddProductSpecificWorkItems(original_state, installer_state, setup_path,
                               new_version, current_version,
                               add_language_identifier, install_list);
 
-  // Copy over brand, usagestats, and other values.
-  AddGoogleUpdateWorkItems(original_state, installer_state, install_list);
-
   // Migrate usagestats back to Chrome.
-  AddMigrateUsageStatesWorkItems(original_state, installer_state, install_list);
+  AddMigrateUsageStatsWorkItems(original_state, installer_state, install_list);
 
   // Append the tasks that run after the installation.
   AppendPostInstallTasks(installer_state,
                          setup_path,
                          current_version,
                          new_version,
                          install_list);
 }
 
-void AddRegisterComDllWorkItems(const base::FilePath& dll_folder,
-                                const std::vector<base::FilePath>& dll_list,
-                                bool system_level,
-                                bool do_register,
-                                bool best_effort,
-                                WorkItemList* work_item_list) {
-  DCHECK(work_item_list);
-  if (dll_list.empty()) {
-    VLOG(1) << "No COM DLLs to register";
-  } else {
-    std::vector<base::FilePath>::const_iterator dll_iter(dll_list.begin());
-    for (; dll_iter != dll_list.end(); ++dll_iter) {
-      base::FilePath dll_path = dll_folder.Append(*dll_iter);
-      WorkItem* work_item = work_item_list->AddSelfRegWorkItem(
-          dll_path.value(), do_register, !system_level);
-      DCHECK(work_item);
-      work_item->set_best_effort(best_effort);
-    }
-  }
-}
-
 void AddSetMsiMarkerWorkItem(const InstallerState& installer_state,
                              BrowserDistribution* dist,
                              bool set,
                              WorkItemList* work_item_list) {
   DCHECK(work_item_list);
   DWORD msi_value = set ? 1 : 0;
   WorkItem* set_msi_work_item =
       work_item_list->AddSetRegValueWorkItem(installer_state.root_key(),
                                              dist->GetStateKey(),
                                              KEY_WOW64_32KEY,
                                              google_update::kRegMSIField,
                                              msi_value,
                                              true);
   DCHECK(set_msi_work_item);
   set_msi_work_item->set_best_effort(true);
   set_msi_work_item->set_log_message("Could not write MSI marker!");
 }
 
 void AddCleanupDeprecatedPerUserRegistrationsWorkItems(const Product& product,
                                                        WorkItemList* list) {
-  if (product.is_chrome()) {
-    BrowserDistribution* dist = product.distribution();
+  BrowserDistribution* dist = product.distribution();
 
-    // TODO(gab): Remove cleanup code for Metro after M53.
-    VLOG(1) << "Adding unregistration items for per-user Metro keys.";
-    list->AddDeleteRegKeyWorkItem(HKEY_CURRENT_USER,
-                                  dist->GetRegistryPath() + L"\\Metro",
-                                  KEY_WOW64_32KEY);
-    list->AddDeleteRegKeyWorkItem(HKEY_CURRENT_USER,
-                                  dist->GetRegistryPath() + L"\\Metro",
-                                  KEY_WOW64_64KEY);
-  }
+  // TODO(gab): Remove cleanup code for Metro after M53.

[robertshield, 2017/01/04 14:23:18]

Can this be removed now?

[grt (UTC plus 2), 2017/01/05 13:08:29]

While the cleanup shipped in M49, we still have over 9% of active users on M48
and older. I'm not sure if this number is dropping over time due to clients
updating or being retired. If it's still helping users as they get up-to-date,
I'm inclined to keep it for now. WDYT?

[robertshield, 2017/01/05 14:20:59]

SGTM, maybe update the comment?

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

What a good idea! Done! :-)

+  VLOG(1) << "Adding unregistration items for per-user Metro keys.";
+  list->AddDeleteRegKeyWorkItem(
+      HKEY_CURRENT_USER, dist->GetRegistryPath() + L"\\Metro", KEY_WOW64_32KEY);
+  list->AddDeleteRegKeyWorkItem(
+      HKEY_CURRENT_USER, dist->GetRegistryPath() + L"\\Metro", KEY_WOW64_64KEY);
 }
 
 void AddActiveSetupWorkItems(const InstallerState& installer_state,
                              const base::Version& new_version,
                              const Product& product,
                              WorkItemList* list) {
   DCHECK(installer_state.operation() != InstallerState::UNINSTALL);
   BrowserDistribution* dist = product.distribution();
 
-  if (!product.is_chrome() || !installer_state.system_install()) {
+  if (!installer_state.system_install()) {
     const char* install_level =
         installer_state.system_install() ? "system" : "user";
     VLOG(1) << "No Active Setup processing to do for " << install_level
             << "-level " << dist->GetDisplayName();
     return;
   }
   DCHECK(installer_state.RequiresActiveSetup());
 
   const HKEY root = HKEY_LOCAL_MACHINE;
   const base::string16 active_setup_path(InstallUtil::GetActiveSetupPath(dist));
@@ skipping 35 matching lines @@
                                active_setup_path,
                                WorkItem::kWow64Default,
                                L"IsInstalled",
                                static_cast<DWORD>(1U),
                                true);
 
   list->AddWorkItem(new UpdateActiveSetupVersionWorkItem(
       active_setup_path, UpdateActiveSetupVersionWorkItem::UPDATE));
 }
 
-void AddDeleteOldIELowRightsPolicyWorkItems(
-    const InstallerState& installer_state,
-    WorkItemList* install_list) {
-  DCHECK(install_list);
-
-  base::string16 key_path;
-  GetOldIELowRightsElevationPolicyKeyPath(&key_path);
-  install_list->AddDeleteRegKeyWorkItem(
-      installer_state.root_key(), key_path, WorkItem::kWow64Default);
-}
-
 void AppendUninstallCommandLineFlags(const InstallerState& installer_state,
                                      const Product& product,
                                      base::CommandLine* uninstall_cmd) {
   DCHECK(uninstall_cmd);
 
   uninstall_cmd->AppendSwitch(installer::switches::kUninstall);
 
   // Append the product-specific uninstall flags.
   product.AppendProductFlags(uninstall_cmd);
   if (installer_state.is_msi())
     uninstall_cmd->AppendSwitch(installer::switches::kMsi);
   if (installer_state.system_install())
     uninstall_cmd->AppendSwitch(installer::switches::kSystemLevel);
   if (installer_state.verbose_logging())
     uninstall_cmd->AppendSwitch(installer::switches::kVerboseLogging);
 }
 
-void RefreshElevationPolicy() {
-  const wchar_t kIEFrameDll[] = L"ieframe.dll";
-  const char kIERefreshPolicy[] = "IERefreshElevationPolicy";
-
-  HMODULE ieframe = LoadLibrary(kIEFrameDll);
-  if (ieframe) {
-    typedef HRESULT (__stdcall *IERefreshPolicy)();
-    IERefreshPolicy ie_refresh_policy = reinterpret_cast<IERefreshPolicy>(
-        GetProcAddress(ieframe, kIERefreshPolicy));
-
-    if (ie_refresh_policy) {
-      ie_refresh_policy();
-    } else {
-      VLOG(1) << kIERefreshPolicy << " not supported.";
-    }
-
-    FreeLibrary(ieframe);
-  } else {
-    VLOG(1) << "Cannot load " << kIEFrameDll;
-  }
-}
-
 void AddOsUpgradeWorkItems(const InstallerState& installer_state,
                            const base::FilePath& setup_path,
                            const base::Version& new_version,
                            const Product& product,
                            WorkItemList* install_list) {
   const HKEY root_key = installer_state.root_key();
   base::string16 cmd_key(
       GetRegCommandKey(product.distribution(), kCmdOnOsUpgrade));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
@@ skipping 13 matching lines @@
       cmd_line.AppendSwitch(installer::switches::kSystemLevel);
     // Log everything for now.
     cmd_line.AppendSwitch(installer::switches::kVerboseLogging);
 
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_is_auto_run_on_os_upgrade(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, install_list);
   }
 }
 
-void AddQuickEnableChromeFrameWorkItems(const InstallerState& installer_state,
-                                        WorkItemList* work_item_list) {
-  DCHECK(work_item_list);
-
-  base::string16 cmd_key(
-      GetRegCommandKey(BrowserDistribution::GetSpecificDistribution(
-                           BrowserDistribution::CHROME_BINARIES),
-                       kCmdQuickEnableCf));
-
-  // Unconditionally remove the legacy Quick Enable command from the binaries.
-  // Do this even if multi-install Chrome isn't installed to ensure that it is
-  // not left behind in any case.
-  work_item_list->AddDeleteRegKeyWorkItem(
-                      installer_state.root_key(), cmd_key, KEY_WOW64_32KEY)
-      ->set_log_message("removing " + base::UTF16ToASCII(kCmdQuickEnableCf) +
-                        " command");
-}
-
 }  // namespace installer