Move GetBaseAppName into install_static.

chrome/installer/setup/uninstall.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 the methods useful for uninstalling Chrome.
 
 #include "chrome/installer/setup/uninstall.h"
 
 #include <windows.h>
 #include <stddef.h>
@@ skipping 664 matching lines @@
                   ShellUtil::kRegStartMenuInternet).c_str(),
               WorkItem::kWow64Default, NULL,
               InstallUtil::ValueEquals(client_name));
         }
       }
     }
   }
 
   // Delete Software\RegisteredApplications\Chromium
   InstallUtil::DeleteRegistryValue(
-      root, ShellUtil::kRegRegisteredApplications,
-      WorkItem::kWow64Default,
-      dist->GetBaseAppName() + browser_entry_suffix);
+      root, ShellUtil::kRegRegisteredApplications, WorkItem::kWow64Default,
+      install_static::GetBaseAppName().append(browser_entry_suffix));
 
   // Delete the App Paths and Applications keys that let Explorer find Chrome:
   // http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121
   base::string16 app_key(ShellUtil::kRegClasses);
   app_key.push_back(base::FilePath::kSeparators[0]);
   app_key.append(L"Applications");
   app_key.push_back(base::FilePath::kSeparators[0]);
   app_key.append(installer::kChromeExe);
   InstallUtil::DeleteRegistryKey(root, app_key, WorkItem::kWow64Default);
 
@@ skipping 27 matching lines @@
   }
 
   // Cleanup in case Chrome had been made the default browser.
 
   // Delete the default value of SOFTWARE\Clients\StartMenuInternet if it
   // references this Chrome.  Do this explicitly here for the case where HKCU is
   // being processed; the iteration above will have no hits since registration
   // lives in HKLM.
   InstallUtil::DeleteRegistryValueIf(
       root, ShellUtil::kRegStartMenuInternet, WorkItem::kWow64Default, NULL,
-      InstallUtil::ValueEquals(dist->GetBaseAppName() + browser_entry_suffix));
+      InstallUtil::ValueEquals(
+          install_static::GetBaseAppName().append(browser_entry_suffix)));
 
   // Delete each protocol association if it references this Chrome.
   InstallUtil::ProgramCompare open_command_pred(chrome_exe);
   base::string16 parent_key(ShellUtil::kRegClasses);
   parent_key.push_back(base::FilePath::kSeparators[0]);
   const base::string16::size_type base_length = parent_key.size();
   base::string16 child_key;
   for (const wchar_t* const* proto =
            &ShellUtil::kPotentialProtocolAssociations[0];
        *proto != NULL;
@@ skipping 21 matching lines @@
 #if defined(GOOGLE_CHROME_BUILD)
 const wchar_t kChromeExtProgId[] = L"ChromeExt";
 #else
 const wchar_t kChromeExtProgId[] = L"ChromiumExt";
 #endif
 
   HKEY roots[] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
   for (size_t i = 0; i < arraysize(roots); ++i) {
     base::string16 suffix;
     if (roots[i] == HKEY_LOCAL_MACHINE)
-      suffix = ShellUtil::GetCurrentInstallationSuffix(dist, chrome_exe);
+      suffix = ShellUtil::GetCurrentInstallationSuffix(chrome_exe);
 
     // Delete Software\Classes\ChromeExt,
     base::string16 ext_prog_id(ShellUtil::kRegClasses);
     ext_prog_id.push_back(base::FilePath::kSeparators[0]);
     ext_prog_id.append(kChromeExtProgId);
     ext_prog_id.append(suffix);
     InstallUtil::DeleteRegistryKey(roots[i], ext_prog_id,
                                    WorkItem::kWow64Default);
 
     // Delete Software\Classes\.crx,
@@ skipping 15 matching lines @@
 
 InstallStatus UninstallProduct(const InstallationState& original_state,
                                const InstallerState& installer_state,
                                const base::FilePath& setup_exe,
                                const Product& product,
                                bool remove_all,
                                bool force_uninstall,
                                const base::CommandLine& cmd_line) {
   InstallStatus status = installer::UNINSTALL_CONFIRMED;
   BrowserDistribution* browser_dist = product.distribution();
-  DCHECK_EQ(BrowserDistribution::GetDistribution(), browser_dist);
   const base::FilePath chrome_exe(
       installer_state.target_path().Append(installer::kChromeExe));
 
   VLOG(1) << "UninstallProduct: " << browser_dist->GetDisplayName();
 
   if (force_uninstall) {
     // Since --force-uninstall command line option is used, we are going to
     // do silent uninstall. Try to close all running Chrome instances.
     CloseAllChromeProcesses();
   } else {
     // no --force-uninstall so lets show some UI dialog boxes.
     status = IsChromeActiveOrUserCancelled(installer_state, product);
     if (status != installer::UNINSTALL_CONFIRMED &&
         status != installer::UNINSTALL_DELETE_PROFILE)
       return status;
 
     const base::string16 suffix(
-        ShellUtil::GetCurrentInstallationSuffix(browser_dist, chrome_exe));
+        ShellUtil::GetCurrentInstallationSuffix(chrome_exe));
 
     // Check if we need admin rights to cleanup HKLM (the conditions for
     // requiring a cleanup are the same as the conditions to do the actual
     // cleanup where DeleteChromeRegistrationKeys() is invoked for
     // HKEY_LOCAL_MACHINE below). If we do, try to launch another uninstaller
     // (silent) in elevated mode to do HKLM cleanup.
     // And continue uninstalling in the current process also to do HKCU cleanup.
     if (remove_all &&
-        ShellUtil::QuickIsChromeRegisteredInHKLM(
-            browser_dist, chrome_exe, suffix) &&
+        ShellUtil::QuickIsChromeRegisteredInHKLM(chrome_exe, suffix) &&
         !::IsUserAnAdmin() &&
         base::win::GetVersion() >= base::win::VERSION_VISTA &&
         !cmd_line.HasSwitch(installer::switches::kRunAsAdmin)) {
       base::CommandLine new_cmd(base::CommandLine::NO_PROGRAM);
       new_cmd.AppendArguments(cmd_line, true);
       // Append --run-as-admin flag to let the new instance of setup.exe know
       // that we already tried to launch ourselves as admin.
       new_cmd.AppendSwitch(installer::switches::kRunAsAdmin);
       // Append --remove-chrome-registration to remove registry keys only.
       new_cmd.AppendSwitch(installer::switches::kRemoveChromeRegistration);
@@ skipping 51 matching lines @@
 
   // Also try to delete the MSI value in the ClientState key (it might not be
   // there). This is due to a Google Update behaviour where an uninstall and a
   // rapid reinstall might result in stale values from the old ClientState key
   // being picked up on reinstall.
   product.SetMsiMarker(installer_state.system_install(), false);
 
   InstallStatus ret = installer::UNKNOWN_STATUS;
 
   const base::string16 suffix(
-      ShellUtil::GetCurrentInstallationSuffix(browser_dist, chrome_exe));
+      ShellUtil::GetCurrentInstallationSuffix(chrome_exe));
 
   // Remove all Chrome registration keys.
   // Registration data is put in HKCU for both system level and user level
   // installs.
   DeleteChromeRegistrationKeys(installer_state, browser_dist, HKEY_CURRENT_USER,
                                suffix, &ret);
 
   // If the user's Chrome is registered with a suffix: it is possible that old
   // unsuffixed registrations were left in HKCU (e.g. if this install was
   // previously installed with no suffix in HKCU (old suffix rules if the user
@@ skipping 25 matching lines @@
     // integration entries registered with |suffix| (note: |suffix| will be the
     // empty string if required as it is obtained by
     // GetCurrentInstallationSuffix() above)).
     // TODO(gab): This can still leave parts of a suffixed install behind. To be
     // able to remove them we would need to be able to remove only suffixed
     // entries (as it is now some of the registry entries (e.g. App Paths) are
     // unsuffixed; thus removing suffixed installs is prohibited in HKLM if
     // !|remove_all| for now).
     if (installer_state.system_install() ||
         (remove_all &&
-         ShellUtil::QuickIsChromeRegisteredInHKLM(
-             browser_dist, chrome_exe, suffix))) {
+         ShellUtil::QuickIsChromeRegisteredInHKLM(chrome_exe, suffix))) {
       DeleteChromeRegistrationKeys(installer_state, browser_dist,
                                    HKEY_LOCAL_MACHINE, suffix, &ret);
     }
 
     ProcessChromeWorkItems(installer_state, product);
 
     UninstallActiveSetupEntries(installer_state);
 
     UninstallFirewallRules(browser_dist, chrome_exe);
 
@@ skipping 124 matching lines @@
     // If we need a reboot to continue, schedule the parent directories for
     // deletion unconditionally. If they are not empty, the session manager
     // will not delete them on reboot.
     ScheduleParentAndGrandparentForDeletion(target_path);
   } else if (DeleteChromeDirectoriesIfEmpty(target_path) == DELETE_FAILED) {
     *uninstall_status = UNINSTALL_FAILED;
   }
 }
 
 }  // namespace installer