Allow two user level installs of Chrome to have default browser settings.

chrome/installer/setup/uninstall.cc

 // Copyright (c) 2009 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 "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 225 matching lines @@
   } else {
     LOG(ERROR) << "Failed to launch chrome.exe for uninstall confirmation.";
   }
 
   return installer_util::UNINSTALL_CONFIRMED;
 }
 }  // namespace
 
 
 bool installer_setup::DeleteChromeRegistrationKeys(HKEY root,
+    const std::wstring& browser_entry_suffix,
     installer_util::InstallStatus& exit_code) {
   RegKey key(root, L"", KEY_ALL_ACCESS);
 
   // Delete Software\Classes\ChromeHTML,
   std::wstring html_prog_id(ShellUtil::kRegClasses);
   file_util::AppendToPath(&html_prog_id, ShellUtil::kChromeHTMLProgId);
   DeleteRegistryKey(key, html_prog_id);
 
   // Delete Software\Classes\ChromeExt,
   std::wstring ext_prog_id(ShellUtil::kRegClasses);
   file_util::AppendToPath(&ext_prog_id, ShellUtil::kChromeExtProgId);
   DeleteRegistryKey(key, ext_prog_id);
 
   // Delete Software\Classes\.crx,
   std::wstring ext_association(ShellUtil::kRegClasses);
   ext_association.append(L"\\.");
   ext_association.append(chrome::kExtensionFileExtension);
   DeleteRegistryKey(key, ext_association);
 
-  // Delete Software\Clients\StartMenuInternet\chrome.exe
+  // Delete Software\Clients\StartMenuInternet\Chromium
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring set_access_key(ShellUtil::kRegStartMenuInternet);
   file_util::AppendToPath(&set_access_key, dist->GetApplicationName());
   DeleteRegistryKey(key, set_access_key);
+
   // We have renamed the StartMenuInternet\chrome.exe to
   // StartMenuInternet\Chromium so for old users we still need to delete
   // the old key.
   std::wstring old_set_access_key(ShellUtil::kRegStartMenuInternet);
   file_util::AppendToPath(&old_set_access_key, installer_util::kChromeExe);
   DeleteRegistryKey(key, old_set_access_key);
 
-  // Delete Software\RegisteredApplications\Chrome
+  // Delete Software\RegisteredApplications\Chromium
   DeleteRegistryValue(root, ShellUtil::kRegRegisteredApplications,
                       dist->GetApplicationName());
 
+  // Delete Software\Classes\ChromeHTML.<user>
+  // Delete Software\Classes\ChromeExt.<user>
+  // Delete Software\Clients\StartMenuInternet\Chromium.<user>
+  // Delete Software\RegisteredApplications\Chromium.<user>
+  if (!browser_entry_suffix.empty()) {
+    html_prog_id.append(browser_entry_suffix);
+    DeleteRegistryKey(key, html_prog_id);
+    ext_prog_id.append(browser_entry_suffix);
+    DeleteRegistryKey(key, ext_prog_id);
+    set_access_key.append(browser_entry_suffix);
+    DeleteRegistryKey(key, set_access_key);
+    DeleteRegistryValue(root, ShellUtil::kRegRegisteredApplications,
+                        dist->GetApplicationName() + browser_entry_suffix);
+  }
+
   // Delete Software\Classes\Applications\chrome.exe
   std::wstring app_key(ShellUtil::kRegClasses);
   file_util::AppendToPath(&app_key, L"Applications");
   file_util::AppendToPath(&app_key, installer_util::kChromeExe);
   DeleteRegistryKey(key, app_key);
 
   // Delete the App Paths key that lets explorer find Chrome.
   std::wstring app_path_key(ShellUtil::kAppPathsRegistryKey);
   file_util::AppendToPath(&app_path_key, installer_util::kChromeExe);
   DeleteRegistryKey(key, app_path_key);
 
   //Cleanup OpenWithList
   for (int i = 0; ShellUtil::kFileAssociations[i] != NULL; i++) {
     std::wstring open_with_key(ShellUtil::kRegClasses);
     file_util::AppendToPath(&open_with_key, ShellUtil::kFileAssociations[i]);
     file_util::AppendToPath(&open_with_key, L"OpenWithList");
     file_util::AppendToPath(&open_with_key, installer_util::kChromeExe);
     DeleteRegistryKey(key, open_with_key);
   }
 
   key.Close();
   exit_code = installer_util::UNINSTALL_SUCCESSFUL;
   return true;
 }
 
 installer_util::InstallStatus installer_setup::UninstallChrome(
     const std::wstring& exe_path, bool system_uninstall,
     bool remove_all, bool force_uninstall,
     const CommandLine& cmd_line, const wchar_t* cmd_params) {
+  std::wstring suffix;
+  ShellUtil::GetUserSpecificDefaultBrowserSuffix(&suffix);
   installer_util::InstallStatus status = installer_util::UNINSTALL_CONFIRMED;
   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(system_uninstall);
     if (status != installer_util::UNINSTALL_CONFIRMED &&
         status != installer_util::UNINSTALL_DELETE_PROFILE)
       return status;
 
     // Check if we need admin rights to cleanup HKLM. 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::AdminNeededForRegistryCleanup() &&
         !::IsUserAnAdmin() &&
         (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA) &&
         !cmd_line.HasSwitch(installer_util::switches::kRunAsAdmin)) {
       std::wstring exe = cmd_line.program();
       std::wstring params(cmd_params);
       // Append --run-as-admin flag to let the new instance of setup.exe know
       // that we already tried to launch ourselves as admin.
       params.append(L" --");
       params.append(installer_util::switches::kRunAsAdmin);
       // Append --remove-chrome-registration to remove registry keys only.
       params.append(L" --");
       params.append(installer_util::switches::kRemoveChromeRegistration);
+      if (!suffix.empty()) {
+        params.append(L" --");
+        params.append(installer_util::switches::kRegisterChromeBrowserSuffix);
+        params.append(L"=\"" + suffix + L"\"");
+      }
       DWORD exit_code = installer_util::UNKNOWN_STATUS;
       InstallUtil::ExecuteExeAsAdmin(exe, params, &exit_code);
     }
   }
 
   // Get the version of installed Chrome (if any)
   scoped_ptr<installer::Version>
       installed_version(InstallUtil::GetChromeVersion(system_uninstall));
 
   // Chrome is not in use so lets uninstall Chrome by deleting various files
@@ skipping 11 matching lines @@
   // Note that we must retrieve the distribution-specific data before deleting
   // dist->GetVersionKey().
   std::wstring distribution_data(dist->GetDistributionData(&key));
 
   // Remove Control Panel uninstall link and Omaha product key.
   DeleteRegistryKey(key, dist->GetUninstallRegPath());
   DeleteRegistryKey(key, dist->GetVersionKey());
 
   // Remove all Chrome registration keys.
   installer_util::InstallStatus ret = installer_util::UNKNOWN_STATUS;
-  DeleteChromeRegistrationKeys(reg_root, ret);
+  DeleteChromeRegistrationKeys(reg_root, suffix, ret);
 
   // For user level install also we end up creating some keys in HKLM if user
   // sets Chrome as default browser. So delete those as well (needs admin).
   if (remove_all && !system_uninstall)
-    DeleteChromeRegistrationKeys(HKEY_LOCAL_MACHINE, ret);
+    DeleteChromeRegistrationKeys(HKEY_LOCAL_MACHINE, suffix, ret);
 
   // Delete shared registry keys as well (these require admin rights) if
   // remove_all option is specified.
   if (remove_all) {
     // Delete media player registry key that exists only in HKLM.
     RegKey hklm_key(HKEY_LOCAL_MACHINE, L"", KEY_ALL_ACCESS);
     std::wstring reg_path(installer::kMediaPlayerRegPath);
     file_util::AppendToPath(&reg_path, installer_util::kChromeExe);
     DeleteRegistryKey(hklm_key, reg_path);
     hklm_key.Close();
@@ skipping 31 matching lines @@
                                     distribution_data);
   }
 
   // Try and delete the preserved local state once the post-install
   // operations are complete.
   if (!local_state_path.empty())
     file_util::Delete(local_state_path, false);
 
   return ret;
 }