Use InstallDetails in 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
@@ skipping 14 matching lines @@
 #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/install_static/install_details.h"
 #include "chrome/installer/setup/app_launcher_installer.h"
+#include "chrome/installer/setup/brand_constants.h"
 #include "chrome/installer/setup/install.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"
@@ skipping 192 matching lines @@
   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);
 
 #if defined(GOOGLE_CHROME_BUILD)
-      if (!InstallUtil::IsChromeSxSProcess()) {
+      if (GetBrandConstants().supported_app_launcher) {
         // 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);
@@ skipping 618 matching lines @@
 // 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())
+  // This operation doesn't apply to modes that don't support multi-install.
+  if (!install_static::InstallDetails::Get().supports_multi_install())
     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;
   }
@@ skipping 221 matching lines @@
                        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())
+  if (GetBrandConstants().supported_app_launcher)
     AddRemoveLegacyAppHostExeWorkItems(target_path, temp_path, install_list);
 #endif  // GOOGLE_CHROME_BUILD
 
   // 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.
@@ skipping 15 matching lines @@
                            add_language_identifier,
                            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()) {
+  // Ensure that the Clients key for the binaries is gone for single installs of
+  // multi-capable products.
+  if (install_static::InstallDetails::Get().supports_multi_install() &&
+      !installer_state.is_multi_install()) {
     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())
+  if (GetBrandConstants().supported_app_launcher)

[robertshield, 2016/11/04 12:50:35]

I don't have a suggestion, more of an observation: it's a little confusing from
a reader's perspective that some supported_XXX values are on the brand constants
and some are in the install details. 

Would it be possible to unify these somehow in a future CL?

[grt (UTC plus 2), 2016/11/08 13:02:13]

I wouldn't object to resolving it now somehow. Here's my dilemma:

There are three categories (maybe more) of constants that are brand and mode
specific:
- Those used in chrome_elf for the bare minimum needed to bootstrap crashpad.
- Those used in the product for all sorts of things (e.g., string identifiers).
- Those used in the installer.

Part of me wants these to be separate buckets so that the union of the three
isn't present in each binary. The downside to this is that there's this somewhat
odd partitioning with parallel structures in the three domains. Another part of
me wants them to be unified in one structure so that there's one and only one
home for the sauce that differs between brands/modes.

Do you have any thoughts? Is the confusion around multiple locations big enough
to justify lumping them all together?

[robertshield, 2016/11/08 22:03:40]

Thought about this for a bit and I'm not sure if the benefits of excluding the
unneeded state from the parts that don't need it really outweigh the cognitive
load needed to understand that there are three places where state is saved and
various combinations of those three are needed in different places. 

Doesn't need to be addressed here but on the whole I'd aim for unifying them in
the near future.

[grt (UTC plus 2), 2016/11/10 15:18:03]

Now is as good a time as any. WDYT?

     AddRemoveLegacyAppCommandsWorkItems(installer_state, install_list);
 #endif  // GOOGLE_CHROME_BUILD
 
   // 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.
@@ skipping 223 matching lines @@
   // 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