Move GetBaseAppName into install_static.

chrome/installer/util/shell_util.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 defines functions that integrate Chrome in Windows shell. These
 // functions can be used by Chrome as well as Chrome installer. All of the
 // work is done by the local functions defined in anonymous namespace in
 // this class.
 
 #include "chrome/installer/util/shell_util.h"
@@ skipping 86 matching lines @@
   // registrations must be preserved).
   base::string16 new_style_suffix;
   if (ShellUtil::GetUserSpecificRegistrySuffix(&new_style_suffix) &&
       suffix == new_style_suffix && chrome_html.length() > 39) {
     NOTREACHED();
     chrome_html.erase(39);
   }
   return chrome_html;
 }
 
+// Returns the browser's application name. This application name will be
+// suffixed as is appropriate for the current install. This is the name that is
+// registered with Default Programs on Windows and that should thus be used to
+// "make chrome default" and such.
+base::string16 GetApplicationName(const base::FilePath& chrome_exe) {
+  return install_static::GetBaseAppName().append(
+      ShellUtil::GetCurrentInstallationSuffix(chrome_exe));
+}
+
 // This class is used to initialize and cache a base 32 encoding of the md5 hash
 // of this user's sid preceded by a dot.
 // This is guaranteed to be unique on the machine and 27 characters long
 // (including the '.').
 // This is then meant to be used as a suffix on all registrations that may
 // conflict with another user-level Chrome install.
 class UserSpecificRegistrySuffix {
  public:
   // All the initialization is done in the constructor to be able to build the
   // suffix in a thread-safe manner when used in conjunction with a
@@ skipping 74 matching lines @@
   base::string16 delegate_clsid;
 };
 
 // Returns the Windows browser client registration key for Chrome.  For example:
 // "Software\Clients\StartMenuInternet\Chromium[.user]".  Strictly speaking, we
 // should use the name of the executable (e.g., "chrome.exe"), but that ship has
 // sailed.  The cost of switching now is re-prompting users to make Chrome their
 // default browser, which isn't polite.  |suffix| is the user-specific
 // registration suffix; see GetUserSpecificDefaultBrowserSuffix in shell_util.h
 // for details.
-base::string16 GetBrowserClientKey(BrowserDistribution* dist,
-                                   const base::string16& suffix) {
+base::string16 GetBrowserClientKey(const base::string16& suffix) {
   DCHECK(suffix.empty() || suffix[0] == L'.');
   return base::string16(ShellUtil::kRegStartMenuInternet)
       .append(1, L'\\')
-      .append(dist->GetBaseAppName())
+      .append(install_static::GetBaseAppName())
       .append(suffix);
 }
 
 // Returns the Windows Default Programs capabilities key for Chrome.  For
 // example:
 // "Software\Clients\StartMenuInternet\Chromium[.user]\Capabilities".
-base::string16 GetCapabilitiesKey(BrowserDistribution* dist,
-                                  const base::string16& suffix) {
-  return GetBrowserClientKey(dist, suffix).append(L"\\Capabilities");
+base::string16 GetCapabilitiesKey(const base::string16& suffix) {
+  return GetBrowserClientKey(suffix).append(L"\\Capabilities");
 }
 
 // DelegateExecute ProgId. Needed for Chrome Metro in Windows 8. This is only
 // needed for registring a web browser, not for general associations.
 ScopedVector<RegistryEntry> GetChromeDelegateExecuteEntries(
     const base::FilePath& chrome_exe,
     const ApplicationInfo& app_info) {
   ScopedVector<RegistryEntry> entries;
 
   base::string16 app_id_shell_key(ShellUtil::kRegClasses);
@@ skipping 116 matching lines @@
   }
 }
 
 // This method returns a list of all the registry entries that are needed to
 // register this installation's ProgId and AppId. These entries need to be
 // registered in HKLM prior to Win8.
 void GetChromeProgIdEntries(BrowserDistribution* dist,
                             const base::FilePath& chrome_exe,
                             const base::string16& suffix,
                             ScopedVector<RegistryEntry>* entries) {
-  // Assert that this is only called with the one relevant distribution.
-  // TODO(grt): Remove this when BrowserDistribution goes away.
-  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   int chrome_icon_index = install_static::GetIconResourceIndex();
 
   ApplicationInfo app_info;
   app_info.prog_id = GetBrowserProgId(suffix);
   app_info.file_type_name = install_static::GetProgIdDescription();
   // File types associated with Chrome are just given the Chrome icon.
   app_info.file_type_icon_path = chrome_exe;
   app_info.file_type_icon_index = chrome_icon_index;
   app_info.command_line = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
   // For user-level installs: entries for the app id will be in HKCU; thus we
@@ skipping 22 matching lines @@
       entry->set_removal_flag(RegistryEntry::RemovalFlag::KEY);
     // Move |delegate_execute_entries| to |entries|.
     entries->insert(entries->end(), delegate_execute_entries.begin(),
                     delegate_execute_entries.end());
     delegate_execute_entries.weak_clear();
   }
 }
 
 // This method returns a list of the registry entries needed to declare a
 // capability of handling a protocol on Windows.
-void GetProtocolCapabilityEntries(BrowserDistribution* dist,
-                                  const base::string16& suffix,
+void GetProtocolCapabilityEntries(const base::string16& suffix,
                                   const base::string16& protocol,
                                   ScopedVector<RegistryEntry>* entries) {
-  entries->push_back(new RegistryEntry(
-      GetCapabilitiesKey(dist, suffix).append(L"\\URLAssociations"), protocol,
-      GetBrowserProgId(suffix)));
+  entries->push_back(
+      new RegistryEntry(GetCapabilitiesKey(suffix).append(L"\\URLAssociations"),
+                        protocol, GetBrowserProgId(suffix)));
 }
 
 // This method returns a list of the registry entries required to register this
 // installation in "RegisteredApplications" on Windows (to appear in Default
 // Programs, StartMenuInternet, etc.). These entries need to be registered in
 // HKLM prior to Win8. If |suffix| is not empty, these entries are guaranteed to
 // be unique on this machine.
 void GetShellIntegrationEntries(BrowserDistribution* dist,
                                 const base::FilePath& chrome_exe,
                                 const base::string16& suffix,
                                 ScopedVector<RegistryEntry>* entries) {
-  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   const base::string16 icon_path(ShellUtil::FormatIconLocation(
       chrome_exe, install_static::GetIconResourceIndex()));
   const base::string16 quoted_exe_path(L"\"" + chrome_exe.value() + L"\"");
 
   // Register for the Start Menu "Internet" link (pre-Win7).
-  const base::string16 start_menu_entry(GetBrowserClientKey(dist, suffix));
+  const base::string16 start_menu_entry(GetBrowserClientKey(suffix));
   // Register Chrome's display name.
   // TODO(grt): http://crbug.com/75152 Also set LocalizedString; see
   // http://msdn.microsoft.com/en-us/library/windows/desktop/cc144109(v=VS.85).aspx#registering_the_display_name
   entries->push_back(
       new RegistryEntry(start_menu_entry, dist->GetDisplayName()));
   // Register the "open" verb for launching Chrome via the "Internet" link.
   entries->push_back(new RegistryEntry(
       start_menu_entry + ShellUtil::kRegShellOpen, quoted_exe_path));
   // Register Chrome's icon for the Start Menu "Internet" link.
   entries->push_back(new RegistryEntry(
       start_menu_entry + ShellUtil::kRegDefaultIcon, icon_path));
 
   // Register installation information.
   base::string16 install_info(start_menu_entry + L"\\InstallInfo");
   // Note: not using CommandLine since it has ambiguous rules for quoting
   // strings.
   entries->push_back(
       new RegistryEntry(install_info, kReinstallCommand,
                         quoted_exe_path + L" --" +
                             base::ASCIIToUTF16(switches::kMakeDefaultBrowser)));
   entries->push_back(new RegistryEntry(
       install_info, L"HideIconsCommand",
       quoted_exe_path + L" --" + base::ASCIIToUTF16(switches::kHideIcons)));
   entries->push_back(new RegistryEntry(
       install_info, L"ShowIconsCommand",
       quoted_exe_path + L" --" + base::ASCIIToUTF16(switches::kShowIcons)));
   entries->push_back(new RegistryEntry(install_info, L"IconsVisible", 1));
 
   // Register with Default Programs.
-  const base::string16 reg_app_name(dist->GetBaseAppName().append(suffix));
+  const base::string16 reg_app_name(
+      install_static::GetBaseAppName().append(suffix));
   // Tell Windows where to find Chrome's Default Programs info.
-  const base::string16 capabilities(GetCapabilitiesKey(dist, suffix));
+  const base::string16 capabilities(GetCapabilitiesKey(suffix));
   entries->push_back(new RegistryEntry(ShellUtil::kRegRegisteredApplications,
                                        reg_app_name, capabilities));
   // Write out Chrome's Default Programs info.
   // TODO(grt): http://crbug.com/75152 Write a reference to a localized
   // resource rather than this.
   entries->push_back(new RegistryEntry(capabilities,
                                        ShellUtil::kRegApplicationDescription,
                                        dist->GetLongAppDescription()));
   entries->push_back(new RegistryEntry(
       capabilities, ShellUtil::kRegApplicationIcon, icon_path));
@@ skipping 117 matching lines @@
 
   // <root hkey>\Software\Classes\<protocol>\shell\@
   base::string16 protocol_shell_key = url_key + ShellUtil::kRegShellPath;
   entries->push_back(new RegistryEntry(protocol_shell_key, L"open"));
 }
 
 // This method returns a list of all the user level registry entries that are
 // needed to make Chromium default browser on XP. Some of these entries are
 // irrelevant in recent versions of Windows, but we register them anyways as
 // some legacy apps are hardcoded to lookup those values.
-void GetXPStyleDefaultBrowserUserEntries(BrowserDistribution* dist,
-                                         const base::FilePath& chrome_exe,
+void GetXPStyleDefaultBrowserUserEntries(const base::FilePath& chrome_exe,
                                          const base::string16& suffix,
                                          ScopedVector<RegistryEntry>* entries) {
-  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   // File extension associations.
   base::string16 html_prog_id(GetBrowserProgId(suffix));
   for (int i = 0; ShellUtil::kDefaultFileAssociations[i] != NULL; i++) {
     GetAppDefaultRegistrationEntries(
         html_prog_id, ShellUtil::kDefaultFileAssociations[i], true, entries);
   }
 
   // Protocols associations.
   base::string16 chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
   base::string16 chrome_icon = ShellUtil::FormatIconLocation(
       chrome_exe, install_static::GetIconResourceIndex());
   for (int i = 0; ShellUtil::kBrowserProtocolAssociations[i] != NULL; i++) {
     GetXPStyleUserProtocolEntries(ShellUtil::kBrowserProtocolAssociations[i],
                                   chrome_icon, chrome_open, entries);
   }
 
   // start->Internet shortcut.
   base::string16 start_menu(ShellUtil::kRegStartMenuInternet);
-  base::string16 app_name = dist->GetBaseAppName() + suffix;
+  base::string16 app_name = install_static::GetBaseAppName().append(suffix);
   entries->push_back(new RegistryEntry(start_menu, app_name));
 }
 
 // Checks that all |entries| are present on this computer (or absent if their
 // |removal_flag_| is set). |look_for_in| is passed to
 // RegistryEntry::ExistsInRegistry(). Documentation for it can be found there.
 bool AreEntriesAsDesired(const ScopedVector<RegistryEntry>& entries,
                          uint32_t look_for_in) {
   for (const auto* entry : entries) {
     if (entry->ExistsInRegistry(look_for_in) != !entry->IsFlaggedForRemoval())
@@ skipping 19 matching lines @@
   ScopedVector<RegistryEntry> entries;
   GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
   GetShellIntegrationEntries(dist, chrome_exe, suffix, &entries);
   GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // This method checks if Chrome is already registered on the local machine
 // for the requested protocol. It just checks the one value required for this.
 // See RegistryEntry::ExistsInRegistry for the behavior of |look_for_in|.
-bool IsChromeRegisteredForProtocol(BrowserDistribution* dist,
-                                   const base::string16& suffix,
+bool IsChromeRegisteredForProtocol(const base::string16& suffix,
                                    const base::string16& protocol,
                                    uint32_t look_for_in) {
   ScopedVector<RegistryEntry> entries;
-  GetProtocolCapabilityEntries(dist, suffix, protocol, &entries);
+  GetProtocolCapabilityEntries(suffix, protocol, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // This method registers Chrome by launching an elevated setup.exe. That will
 // show the user the standard elevation prompt. If the user accepts it the new
 // process will make the necessary changes and return SUCCESS that we capture
 // and return. If protocol is non-empty we will also register Chrome as being
 // capable of handling the protocol. This is most commonly used on per-user
 // installs on Windows 7 where setup.exe did not have permission to register
 // Chrome during install. It may also be used on all OSs for system-level
@@ skipping 116 matching lines @@
 // |suffix|.
 // |confirmation_level| is the level of verification desired as described in
 // the RegistrationConfirmationLevel enum above.
 // |suffix| can be the empty string (this is used to support old installs
 // where we used to not suffix user-level installs if they were the first to
 // request the non-suffixed registry entries on the machine).
 // NOTE: This a quick check that only validates that a single registry entry
 // points to |chrome_exe|. This should only be used at run-time to determine
 // how Chrome is registered, not to know whether the registration is complete
 // at install-time (IsChromeRegistered() can be used for that).
-bool QuickIsChromeRegistered(BrowserDistribution* dist,
-                             const base::FilePath& chrome_exe,
+bool QuickIsChromeRegistered(const base::FilePath& chrome_exe,
                              const base::string16& suffix,
                              RegistrationConfirmationLevel confirmation_level) {
-  // Assert that this is only called with the one relevant distribution.
-  // TODO(grt): Remove this when BrowserDistribution goes away.
-  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   // Get the appropriate key to look for based on the level desired.
   base::string16 reg_key;
   switch (confirmation_level) {
     case CONFIRM_PROGID_REGISTRATION:
       // Software\Classes\ChromeHTML|suffix|
       reg_key = ShellUtil::kRegClasses;
       reg_key.push_back(base::FilePath::kSeparators[0]);
       reg_key.append(install_static::GetProgIdPrefix());
       reg_key.append(suffix);
       break;
     case CONFIRM_SHELL_REGISTRATION:
     case CONFIRM_SHELL_REGISTRATION_IN_HKLM:
       // Software\Clients\StartMenuInternet\Google Chrome|suffix|
-      reg_key = GetBrowserClientKey(dist, suffix);
+      reg_key = GetBrowserClientKey(suffix);
       break;
     default:
       NOTREACHED();
       break;
   }
   reg_key.append(ShellUtil::kRegShellOpen);
 
   // ProgId registrations are allowed to reside in HKCU for user-level installs
   // (and values there have priority over values in HKLM). The same is true for
   // shell integration entries as of Windows 8.
@@ skipping 19 matching lines @@
 // Sets |suffix| to a 27 character string that is specific to this user on this
 // machine (on user-level installs only).
 // To support old-style user-level installs however, |suffix| is cleared if the
 // user currently owns the non-suffixed HKLM registrations.
 // |suffix| can also be set to the user's username if the current install is
 // suffixed as per the old-style registrations.
 // |suffix| is cleared on system-level installs.
 // |suffix| should then be appended to all Chrome properties that may conflict
 // with other Chrome user-level installs.
 // Returns true unless one of the underlying calls fails.
-bool GetInstallationSpecificSuffix(BrowserDistribution* dist,
-                                   const base::FilePath& chrome_exe,
+bool GetInstallationSpecificSuffix(const base::FilePath& chrome_exe,
                                    base::string16* suffix) {
   if (!InstallUtil::IsPerUserInstall() ||
-      QuickIsChromeRegistered(dist, chrome_exe, base::string16(),
+      QuickIsChromeRegistered(chrome_exe, base::string16(),
                               CONFIRM_SHELL_REGISTRATION)) {
     // No suffix on system-level installs and user-level installs already
     // registered with no suffix.
     suffix->clear();
     return true;
   }
 
   // Get the old suffix for the check below.
   if (!ShellUtil::GetOldUserSpecificRegistrySuffix(suffix)) {
     NOTREACHED();
     return false;
   }
-  if (QuickIsChromeRegistered(dist, chrome_exe, *suffix,
+  if (QuickIsChromeRegistered(chrome_exe, *suffix,
                               CONFIRM_SHELL_REGISTRATION)) {
     // Username suffix for installs that are suffixed as per the old-style.
     return true;
   }
 
   return ShellUtil::GetUserSpecificRegistrySuffix(suffix);
 }
 
 // Returns the root registry key (HKLM or HKCU) under which registrations must
 // be placed for this install. As of Windows 8 everything can go in HKCU for
 // per-user installs.
 HKEY DetermineRegistrationRoot(bool is_per_user) {
   return is_per_user && base::win::GetVersion() >= base::win::VERSION_WIN8 ?
       HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
 }
 
 // Associates Chrome with supported protocols and file associations. This should
 // not be required on Vista+ but since some applications still read
 // Software\Classes\http key directly, we have to do this on Vista+ as well.
-bool RegisterChromeAsDefaultXPStyle(BrowserDistribution* dist,
-                                    int shell_change,
+bool RegisterChromeAsDefaultXPStyle(int shell_change,
                                     const base::FilePath& chrome_exe) {
   bool ret = true;
   ScopedVector<RegistryEntry> entries;
   GetXPStyleDefaultBrowserUserEntries(
-      dist, chrome_exe,
-      ShellUtil::GetCurrentInstallationSuffix(dist, chrome_exe), &entries);
+      chrome_exe, ShellUtil::GetCurrentInstallationSuffix(chrome_exe),
+      &entries);
 
   // Change the default browser for current user.
   if ((shell_change & ShellUtil::CURRENT_USER) &&
       !ShellUtil::AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
     ret = false;
     LOG(ERROR) << "Could not make Chrome default browser (XP/current user).";
   }
 
   // Chrome as default browser at system level.
   if ((shell_change & ShellUtil::SYSTEM_LEVEL) &&
       !ShellUtil::AddRegistryEntries(HKEY_LOCAL_MACHINE, entries)) {
     ret = false;
     LOG(ERROR) << "Could not make Chrome default browser (XP/system level).";
   }
 
   return ret;
 }
 
 // Associates Chrome with |protocol| in the registry. This should not be
 // required on Vista+ but since some applications still read these registry
 // keys directly, we have to do this on Vista+ as well.
 // See http://msdn.microsoft.com/library/aa767914.aspx for more details.
 bool RegisterChromeAsDefaultProtocolClientXPStyle(
-    BrowserDistribution* dist,
     const base::FilePath& chrome_exe,
     const base::string16& protocol) {
-  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   ScopedVector<RegistryEntry> entries;
   const base::string16 chrome_open(
       ShellUtil::GetChromeShellOpenCmd(chrome_exe));
   const base::string16 chrome_icon(ShellUtil::FormatIconLocation(
       chrome_exe, install_static::GetIconResourceIndex()));
   GetXPStyleUserProtocolEntries(protocol, chrome_icon, chrome_open, &entries);
   // Change the default protocol handler for current user.
   if (!ShellUtil::AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
     LOG(ERROR) << "Could not make Chrome default protocol client (XP).";
     return false;
@@ skipping 98 matching lines @@
     const base::FilePath& chrome_exe,
     const wchar_t* const* protocols,
     size_t num_protocols) {
   base::win::ScopedComPtr<IApplicationAssociationRegistration> registration;
   HRESULT hr = registration.CreateInstance(
       CLSID_ApplicationAssociationRegistration, NULL, CLSCTX_INPROC);
   if (FAILED(hr))
     return ShellUtil::UNKNOWN_DEFAULT;
 
   base::string16 prog_id(install_static::GetProgIdPrefix());
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  prog_id += ShellUtil::GetCurrentInstallationSuffix(dist, chrome_exe);
+  prog_id += ShellUtil::GetCurrentInstallationSuffix(chrome_exe);
 
   for (size_t i = 0; i < num_protocols; ++i) {
     base::win::ScopedCoMem<wchar_t> current_app;
     hr = registration->QueryCurrentDefault(protocols[i], AT_URLPROTOCOL,
                                            AL_EFFECTIVE, &current_app);
     if (FAILED(hr) || prog_id.compare(current_app) != 0)
       return ShellUtil::NOT_DEFAULT;
   }
 
   return ShellUtil::IS_DEFAULT;
 }
 
 // Probe using IApplicationAssociationRegistration::QueryAppIsDefault (Vista and
 // Windows 7); see ProbeProtocolHandlers.
 ShellUtil::DefaultState ProbeAppIsDefaultHandlers(
     const base::FilePath& chrome_exe,
     const wchar_t* const* protocols,
     size_t num_protocols) {
   base::win::ScopedComPtr<IApplicationAssociationRegistration> registration;
   HRESULT hr = registration.CreateInstance(
       CLSID_ApplicationAssociationRegistration, NULL, CLSCTX_INPROC);
   if (FAILED(hr))
     return ShellUtil::UNKNOWN_DEFAULT;
 
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  base::string16 app_name(ShellUtil::GetApplicationName(dist, chrome_exe));
+  base::string16 app_name(GetApplicationName(chrome_exe));
 
   BOOL result;
   for (size_t i = 0; i < num_protocols; ++i) {
     result = TRUE;
     hr = registration->QueryAppIsDefault(protocols[i], AT_URLPROTOCOL,
         AL_EFFECTIVE, app_name.c_str(), &result);
     if (FAILED(hr) || result == FALSE)
       return ShellUtil::NOT_DEFAULT;
   }
 
@@ skipping 326 matching lines @@
       icon_index(0),
       pin_to_taskbar(false),
       options(0U) {}
 
 ShellUtil::ShortcutProperties::ShortcutProperties(
     const ShortcutProperties& other) = default;
 
 ShellUtil::ShortcutProperties::~ShortcutProperties() {
 }
 
-bool ShellUtil::QuickIsChromeRegisteredInHKLM(BrowserDistribution* dist,
-                                              const base::FilePath& chrome_exe,
+bool ShellUtil::QuickIsChromeRegisteredInHKLM(const base::FilePath& chrome_exe,
                                               const base::string16& suffix) {
-  return QuickIsChromeRegistered(dist, chrome_exe, suffix,
+  return QuickIsChromeRegistered(chrome_exe, suffix,
                                  CONFIRM_SHELL_REGISTRATION_IN_HKLM);
 }
 
 bool ShellUtil::ShortcutLocationIsSupported(ShortcutLocation location) {
   switch (location) {
     case SHORTCUT_LOCATION_DESKTOP:  // Falls through.
     case SHORTCUT_LOCATION_QUICK_LAUNCH:  // Falls through.
     case SHORTCUT_LOCATION_START_MENU_ROOT:  // Falls through.
     case SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED:  // Falls through.
     case SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR:
       return true;
     case SHORTCUT_LOCATION_TASKBAR_PINS:
       return base::win::GetVersion() >= base::win::VERSION_WIN7;
     case SHORTCUT_LOCATION_APP_SHORTCUTS:
       return base::win::GetVersion() >= base::win::VERSION_WIN8;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool ShellUtil::GetShortcutPath(ShortcutLocation location,
                                 BrowserDistribution* dist,
                                 ShellChange level,
                                 base::FilePath* path) {
+  // Assert that this is only called with the one relevant distribution.
+  // TODO(grt): Remove this when BrowserDistribution goes away.
+  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   DCHECK(path);
-  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   int dir_key = -1;
   base::string16 folder_to_append;
   switch (location) {
     case SHORTCUT_LOCATION_DESKTOP:
       dir_key = (level == CURRENT_USER) ? base::DIR_USER_DESKTOP :
                                           base::DIR_COMMON_DESKTOP;
       break;
     case SHORTCUT_LOCATION_QUICK_LAUNCH:
       // There is no support for a system-level Quick Launch shortcut.
       DCHECK_EQ(level, CURRENT_USER);
@@ skipping 35 matching lines @@
   if (!folder_to_append.empty())
     *path = path->Append(folder_to_append);
 
   return true;
 }
 
 bool ShellUtil::MoveExistingShortcut(ShortcutLocation old_location,
                                      ShortcutLocation new_location,
                                      BrowserDistribution* dist,
                                      const ShortcutProperties& properties) {
+  // Assert that this is only called with the one relevant distribution.
+  // TODO(grt): Remove this when BrowserDistribution goes away.
+  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   // Explicitly whitelist locations to which this is applicable.
   if (old_location != SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED ||
       new_location != SHORTCUT_LOCATION_START_MENU_ROOT) {
     NOTREACHED();
     return false;
   }
 
   base::string16 shortcut_name(
       ExtractShortcutNameFromProperties(dist, properties));
 
   base::FilePath old_shortcut_path;
   base::FilePath new_shortcut_path;
   GetShortcutPath(old_location, dist, properties.level, &old_shortcut_path);
   GetShortcutPath(new_location, dist, properties.level, &new_shortcut_path);
   old_shortcut_path = old_shortcut_path.Append(shortcut_name);
   new_shortcut_path = new_shortcut_path.Append(shortcut_name);
 
   bool result = base::Move(old_shortcut_path, new_shortcut_path);
   RemoveShortcutFolderIfEmpty(old_location, dist, properties.level);
   return result;
 }
 
 bool ShellUtil::CreateOrUpdateShortcut(
     ShortcutLocation location,
     BrowserDistribution* dist,
     const ShortcutProperties& properties,
     ShortcutOperation operation) {
+  // Assert that this is only called with the one relevant distribution.
+  // TODO(grt): Remove this when BrowserDistribution goes away.
+  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   // Explicitly whitelist locations to which this is applicable.
   if (location != SHORTCUT_LOCATION_DESKTOP &&
       location != SHORTCUT_LOCATION_QUICK_LAUNCH &&
       location != SHORTCUT_LOCATION_START_MENU_ROOT &&
       location != SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED &&
       location != SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR) {
     NOTREACHED();
     return false;
   }
 
@@ skipping 88 matching lines @@
     const base::FilePath& chrome_exe) {
   return L"\"" + chrome_exe.value() + L"\" -- \"%1\"";
 }
 
 base::string16 ShellUtil::GetChromeDelegateCommand(
     const base::FilePath& chrome_exe) {
   return L"\"" + chrome_exe.value() + L"\" -- %*";
 }
 
 void ShellUtil::GetRegisteredBrowsers(
-    BrowserDistribution* dist,
     std::map<base::string16, base::string16>* browsers) {
-  DCHECK(dist);
   DCHECK(browsers);
 
   const base::string16 base_key(kRegStartMenuInternet);
   base::string16 client_path;
   RegKey key;
   base::string16 name;
   base::string16 command;
 
   // HKCU has precedence over HKLM for these registrations: http://goo.gl/xjczJ.
   // Look in HKCU second to override any identical values found in HKLM.
   const HKEY roots[] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
   for (const HKEY root : roots) {
     for (base::win::RegistryKeyIterator iter(root, base_key.c_str());
          iter.Valid(); ++iter) {
       client_path.assign(base_key).append(1, L'\\').append(iter.Name());
       // Read the browser's name (localized according to install language).
-      if (key.Open(root, client_path.c_str(),
-                   KEY_QUERY_VALUE) != ERROR_SUCCESS ||
-          key.ReadValue(NULL, &name) != ERROR_SUCCESS ||
-          name.empty() ||
-          name.find(dist->GetBaseAppName()) != base::string16::npos) {
+      if (key.Open(root, client_path.c_str(), KEY_QUERY_VALUE) !=
+              ERROR_SUCCESS ||
+          key.ReadValue(NULL, &name) != ERROR_SUCCESS || name.empty() ||
+          name.find(install_static::GetBaseAppName()) != base::string16::npos) {
         continue;
       }
       // Read the browser's reinstall command.
       if (key.Open(root, (client_path + L"\\InstallInfo").c_str(),
                    KEY_QUERY_VALUE) == ERROR_SUCCESS &&
           key.ReadValue(kReinstallCommand, &command) == ERROR_SUCCESS &&
           !command.empty()) {
         (*browsers)[name] = command;
       }
     }
   }
 }
 
 base::string16 ShellUtil::GetCurrentInstallationSuffix(
-    BrowserDistribution* dist,
     const base::FilePath& chrome_exe) {
   // This method is somewhat the opposite of GetInstallationSpecificSuffix().
   // In this case we are not trying to determine the current suffix for the
   // upcoming installation (i.e. not trying to stick to a currently bad
   // registration style if one is present).
   // Here we want to determine which suffix we should use at run-time.
   // In order of preference, we prefer (for user-level installs):
   //   1) Base 32 encoding of the md5 hash of the user's sid (new-style).
   //   2) Username (old-style).
   //   3) Unsuffixed (even worse).
   base::string16 tested_suffix;
   if (InstallUtil::IsPerUserInstall() &&
       (!GetUserSpecificRegistrySuffix(&tested_suffix) ||
-       !QuickIsChromeRegistered(dist, chrome_exe, tested_suffix,
+       !QuickIsChromeRegistered(chrome_exe, tested_suffix,
                                 CONFIRM_PROGID_REGISTRATION)) &&
       (!GetOldUserSpecificRegistrySuffix(&tested_suffix) ||
-       !QuickIsChromeRegistered(dist, chrome_exe, tested_suffix,
+       !QuickIsChromeRegistered(chrome_exe, tested_suffix,
                                 CONFIRM_PROGID_REGISTRATION)) &&
-      !QuickIsChromeRegistered(dist, chrome_exe, tested_suffix.erase(),
+      !QuickIsChromeRegistered(chrome_exe, tested_suffix.erase(),
                                CONFIRM_PROGID_REGISTRATION)) {
     // If Chrome is not registered under any of the possible suffixes (e.g.
     // tests, Canary, etc.): use the new-style suffix at run-time.
     if (!GetUserSpecificRegistrySuffix(&tested_suffix))
       NOTREACHED();
   }
   return tested_suffix;
 }
 
-base::string16 ShellUtil::GetApplicationName(BrowserDistribution* dist,
-                                             const base::FilePath& chrome_exe) {
-  base::string16 app_name = dist->GetBaseAppName();
-  app_name += GetCurrentInstallationSuffix(dist, chrome_exe);
-  return app_name;
-}
-
 base::string16 ShellUtil::GetBrowserModelId(bool is_per_user_install) {
   base::string16 app_id(install_static::GetBaseAppId());
   base::string16 suffix;
 
   // TODO(robertshield): Temporary hack to make the kRegisterChromeBrowserSuffix
   // apply to all registry values computed down in these murky depths.
   base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(
           installer::switches::kRegisterChromeBrowserSuffix)) {
     suffix = command_line.GetSwitchValueNative(
@@ skipping 110 matching lines @@
   if (base::win::GetVersion() >= base::win::VERSION_WIN10)
     return InteractiveSetDefaultMode::SYSTEM_SETTINGS;
 
   return InteractiveSetDefaultMode::INTENT_PICKER;
 }
 
 bool ShellUtil::MakeChromeDefault(BrowserDistribution* dist,
                                   int shell_change,
                                   const base::FilePath& chrome_exe,
                                   bool elevate_if_not_admin) {
-  DCHECK(!(shell_change & SYSTEM_LEVEL) || IsUserAnAdmin());
-
   // Assert that this is only called with the one relevant distribution.
   // TODO(grt): Remove this when BrowserDistribution goes away.
   DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
+  DCHECK(!(shell_change & SYSTEM_LEVEL) || IsUserAnAdmin());
+
   if (!install_static::SupportsSetAsDefaultBrowser())
     return false;
 
   // Windows 8 does not permit making a browser default just like that.
   // This process needs to be routed through the system's UI. Use
   // ShowMakeChromeDefaultSystemUI instead (below).
   if (!CanMakeChromeDefaultUnattended()) {
     return false;
   }
 
   if (!RegisterChromeBrowser(
            dist, chrome_exe, base::string16(), elevate_if_not_admin)) {
     return false;
   }
 
   bool ret = true;
   // First use the new "recommended" way on Vista to make Chrome default
   // browser.
-  base::string16 app_name = GetApplicationName(dist, chrome_exe);
+  base::string16 app_name = GetApplicationName(chrome_exe);
 
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     // On Windows Vista and Win7 we still can set ourselves via the
     // the IApplicationAssociationRegistration interface.
     VLOG(1) << "Registering Chrome as default browser on Vista.";
     base::win::ScopedComPtr<IApplicationAssociationRegistration> pAAR;
     HRESULT hr = pAAR.CreateInstance(CLSID_ApplicationAssociationRegistration,
         NULL, CLSCTX_INPROC);
     if (SUCCEEDED(hr)) {
       for (int i = 0; kBrowserProtocolAssociations[i] != NULL; i++) {
@@ skipping 13 matching lines @@
         if (!SUCCEEDED(hr)) {
           ret = false;
           LOG(ERROR) << "Failed to register as default for file extension "
                      << kDefaultFileAssociations[i]
                      << " (" << hr << ")";
         }
       }
     }
   }
 
-  if (!RegisterChromeAsDefaultXPStyle(dist, shell_change, chrome_exe))
+  if (!RegisterChromeAsDefaultXPStyle(shell_change, chrome_exe))
     ret = false;
 
   // Send Windows notification event so that it can update icons for
   // file associations.
   SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
   return ret;
 }
 
 bool ShellUtil::ShowMakeChromeDefaultSystemUI(
     BrowserDistribution* dist,
     const base::FilePath& chrome_exe) {
-  DCHECK(!CanMakeChromeDefaultUnattended());
-
   // Assert that this is only called with the one relevant distribution.
   // TODO(grt): Remove this when BrowserDistribution goes away.
   DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
+  DCHECK(!CanMakeChromeDefaultUnattended());
+
   if (!install_static::SupportsSetAsDefaultBrowser())
     return false;
 
   if (!RegisterChromeBrowser(dist, chrome_exe, base::string16(), true))
       return false;
 
   bool succeeded = true;
   bool is_default = (GetChromeDefaultState() == IS_DEFAULT);
   if (!is_default) {
     switch (GetInteractiveSetDefaultMode()) {
@@ skipping 12 matching lines @@
         // So we launch the settings dialog. Quoting from MSDN: "The Open With
         // dialog box can no longer be used to change the default program used
         // to open a file extension. You can only use SHOpenWithDialog to open
         // a single file."
         succeeded = LaunchDefaultAppsSettingsModernDialog(L"http");
         break;
     }
     is_default = (succeeded && GetChromeDefaultState() == IS_DEFAULT);
   }
   if (succeeded && is_default)
-    RegisterChromeAsDefaultXPStyle(dist, CURRENT_USER, chrome_exe);
+    RegisterChromeAsDefaultXPStyle(CURRENT_USER, chrome_exe);
   return succeeded;
 }
 
 bool ShellUtil::MakeChromeDefaultProtocolClient(
     BrowserDistribution* dist,
     const base::FilePath& chrome_exe,
     const base::string16& protocol) {
   // Assert that this is only called with the one relevant distribution.
   // TODO(grt): Remove this when BrowserDistribution goes away.
   DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
@@ skipping 13 matching lines @@
   bool ret = true;
   // First use the new "recommended" way on Vista to make Chrome default
   // protocol handler.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     VLOG(1) << "Registering Chrome as default handler for " << protocol
             << " on Vista.";
     base::win::ScopedComPtr<IApplicationAssociationRegistration> pAAR;
     HRESULT hr = pAAR.CreateInstance(CLSID_ApplicationAssociationRegistration,
       NULL, CLSCTX_INPROC);
     if (SUCCEEDED(hr)) {
-      base::string16 app_name = GetApplicationName(dist, chrome_exe);
+      base::string16 app_name = GetApplicationName(chrome_exe);
       hr = pAAR->SetAppAsDefault(app_name.c_str(), protocol.c_str(),
                                  AT_URLPROTOCOL);
     }
     if (!SUCCEEDED(hr)) {
       ret = false;
       LOG(ERROR) << "Could not make Chrome default protocol client (Vista):"
                  << " HRESULT=" << hr << ".";
     }
   }
 
   // Now use the old way to associate Chrome with the desired protocol. This
   // should not be required on Vista+, but since some applications still read
   // Software\Classes\<protocol> key directly, do this on Vista+ also.
-  if (!RegisterChromeAsDefaultProtocolClientXPStyle(dist, chrome_exe, protocol))
+  if (!RegisterChromeAsDefaultProtocolClientXPStyle(chrome_exe, protocol))
     ret = false;
 
   return ret;
 }
 
 bool ShellUtil::ShowMakeChromeDefaultProtocolClientSystemUI(
     BrowserDistribution* dist,
     const base::FilePath& chrome_exe,
     const base::string16& protocol) {
-  DCHECK(!CanMakeChromeDefaultUnattended());
-
   // Assert that this is only called with the one relevant distribution.
   // TODO(grt): Remove this when BrowserDistribution goes away.
   DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
+  DCHECK(!CanMakeChromeDefaultUnattended());
+
   if (!install_static::SupportsSetAsDefaultBrowser())
     return false;
 
   if (!RegisterChromeForProtocol(
            dist, chrome_exe, base::string16(), protocol, true))
     return false;
 
   bool succeeded = true;
   bool is_default = (
       GetChromeDefaultProtocolClientState(protocol) == IS_DEFAULT);
@@ skipping 13 matching lines @@
       case SYSTEM_SETTINGS:
         // On Windows 10, you can't even launch the associations dialog.
         // So we launch the settings dialog.
         succeeded = LaunchDefaultAppsSettingsModernDialog(protocol.c_str());
         break;
     }
     is_default = (succeeded &&
                   GetChromeDefaultProtocolClientState(protocol) == IS_DEFAULT);
   }
   if (succeeded && is_default)
-    RegisterChromeAsDefaultProtocolClientXPStyle(dist, chrome_exe, protocol);
+    RegisterChromeAsDefaultProtocolClientXPStyle(chrome_exe, protocol);
   return succeeded;
 }
 
 bool ShellUtil::RegisterChromeBrowser(BrowserDistribution* dist,
                                       const base::FilePath& chrome_exe,
                                       const base::string16& unique_suffix,
                                       bool elevate_if_not_admin) {
+  // Assert that this is only called with the one relevant distribution.
+  // TODO(grt): Remove this when BrowserDistribution goes away.
   DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
 
   base::string16 suffix;
   if (!unique_suffix.empty()) {
     suffix = unique_suffix;
   } else if (command_line.HasSwitch(
                  installer::switches::kRegisterChromeBrowserSuffix)) {
     suffix = command_line.GetSwitchValueNative(
         installer::switches::kRegisterChromeBrowserSuffix);
-  } else if (!GetInstallationSpecificSuffix(dist, chrome_exe, &suffix)) {
+  } else if (!GetInstallationSpecificSuffix(chrome_exe, &suffix)) {
     return false;
   }
 
   RemoveRunVerbOnWindows8();
 
   bool user_level = InstallUtil::IsPerUserInstall();
   HKEY root = DetermineRegistrationRoot(user_level);
 
   // Look only in HKLM for system-level installs (otherwise, if a user-level
   // install is also present, it will lead IsChromeRegistered() to think this
@@ skipping 55 matching lines @@
   }
   SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
   return result;
 }
 
 bool ShellUtil::RegisterChromeForProtocol(BrowserDistribution* dist,
                                           const base::FilePath& chrome_exe,
                                           const base::string16& unique_suffix,
                                           const base::string16& protocol,
                                           bool elevate_if_not_admin) {
+  // Assert that this is only called with the one relevant distribution.
+  // TODO(grt): Remove this when BrowserDistribution goes away.
+  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   base::string16 suffix;
   if (!unique_suffix.empty()) {
     suffix = unique_suffix;
-  } else if (!GetInstallationSpecificSuffix(dist, chrome_exe, &suffix)) {
+  } else if (!GetInstallationSpecificSuffix(chrome_exe, &suffix)) {
     return false;
   }
 
   bool user_level = InstallUtil::IsPerUserInstall();
   HKEY root = DetermineRegistrationRoot(user_level);
 
   // Look only in HKLM for system-level installs (otherwise, if a user-level
   // install is also present, it could lead IsChromeRegisteredForProtocol() to
   // think this system-level install isn't registered properly as it may be
   // shadowed by the user-level install's registrations).
   uint32_t look_for_in = user_level ? RegistryEntry::LOOK_IN_HKCU_THEN_HKLM
                                     : RegistryEntry::LOOK_IN_HKLM;
 
   // Check if chrome is already registered with this suffix.
-  if (IsChromeRegisteredForProtocol(dist, suffix, protocol, look_for_in))
+  if (IsChromeRegisteredForProtocol(suffix, protocol, look_for_in))
     return true;
 
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     // We can do this operation directly.
     // First, make sure Chrome is fully registered on this machine.
     if (!RegisterChromeBrowser(dist, chrome_exe, suffix, false))
       return false;
 
     // Write in the capabillity for the protocol.
     ScopedVector<RegistryEntry> entries;
-    GetProtocolCapabilityEntries(dist, suffix, protocol, &entries);
+    GetProtocolCapabilityEntries(suffix, protocol, &entries);
     return AddRegistryEntries(root, entries);
   } else if (elevate_if_not_admin &&
              base::win::GetVersion() >= base::win::VERSION_VISTA) {
     // Elevate to do the whole job
     return ElevateAndRegisterChrome(dist, chrome_exe, suffix, protocol);
   } else {
     // Admin rights are required to register capabilities before Windows 8.
     return false;
   }
 }
 
 // static
 bool ShellUtil::RemoveShortcuts(ShortcutLocation location,
                                 BrowserDistribution* dist,
                                 ShellChange level,
                                 const base::FilePath& target_exe) {
+  // Assert that this is only called with the one relevant distribution.
+  // TODO(grt): Remove this when BrowserDistribution goes away.
+  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   if (!ShortcutLocationIsSupported(location))
     return true;  // Vacuous success.
 
   FilterTargetEq shortcut_filter(target_exe, false);
   // Main operation to apply to each shortcut in the directory specified.
   ShortcutOperationCallback shortcut_operation(
       location == SHORTCUT_LOCATION_TASKBAR_PINS
           ? base::Bind(&ShortcutOpUnpinFromTaskbar)
           : base::Bind(&ShortcutOpDelete));
   bool success = BatchShortcutAction(shortcut_filter.AsShortcutFilterCallback(),
                                      shortcut_operation, location, dist, level,
                                      NULL);
   // Remove chrome-specific shortcut folders if they are now empty.
   if (success &&
       (location == SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED ||
        location == SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR ||
        location == SHORTCUT_LOCATION_APP_SHORTCUTS)) {
     success = RemoveShortcutFolderIfEmpty(location, dist, level);
   }
   return success;
 }
 
 // static
 bool ShellUtil::RetargetShortcutsWithArgs(
     ShortcutLocation location,
     BrowserDistribution* dist,
     ShellChange level,
     const base::FilePath& old_target_exe,
     const base::FilePath& new_target_exe) {
+  // Assert that this is only called with the one relevant distribution.
+  // TODO(grt): Remove this when BrowserDistribution goes away.
+  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   if (!ShortcutLocationIsSupported(location))
     return true;  // Vacuous success.
 
   FilterTargetEq shortcut_filter(old_target_exe, true);
   ShortcutOperationCallback shortcut_operation(
       base::Bind(&ShortcutOpRetarget, old_target_exe, new_target_exe));
   return BatchShortcutAction(shortcut_filter.AsShortcutFilterCallback(),
                              shortcut_operation, location, dist, level, NULL);
 }
 
 // static
 bool ShellUtil::ShortcutListMaybeRemoveUnknownArgs(
     ShortcutLocation location,
     BrowserDistribution* dist,
     ShellChange level,
     const base::FilePath& chrome_exe,
     bool do_removal,
     const scoped_refptr<SharedCancellationFlag>& cancel,
     std::vector<std::pair<base::FilePath, base::string16> >* shortcuts) {
+  // Assert that this is only called with the one relevant distribution.
+  // TODO(grt): Remove this when BrowserDistribution goes away.
+  DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
   if (!ShortcutLocationIsSupported(location))
     return false;
   DCHECK(dist);
   FilterTargetEq shortcut_filter(chrome_exe, true);
   ShortcutOperationCallback shortcut_operation(
       base::Bind(&ShortcutOpListOrRemoveUnknownArgs, do_removal, shortcuts));
   return BatchShortcutAction(shortcut_filter.AsShortcutFilterCallback(),
                              shortcut_operation, location, dist, level, cancel);
 }
 
@@ skipping 80 matching lines @@
        itr != entries.end(); ++itr)
     (*itr)->AddToWorkItemList(root, items.get());
 
   // Apply all the registry changes and if there is a problem, rollback
   if (!items->Do()) {
     items->Rollback();
     return false;
   }
   return true;
 }