Always suffix ChromeHTML entries on Windows for user-level installs.

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 <vector>
 
@@ skipping 202 matching lines @@
     }
   }
 
   if (kill) {
     VLOG(1) << installer::kChromeFrameHelperExe << " hung.  Killing.";
     base::CleanupProcesses(installer::kChromeFrameHelperExe, 0,
                            content::RESULT_CODE_HUNG, NULL);
   }
 }
 
-// This method tries to figure out if current user has registered Chrome.
-// It returns true iff there is a registered browser that will launch the
-// same chrome.exe as the current installation.
-bool CurrentUserHasDefaultBrowser(const InstallerState& installer_state) {
-  using base::win::RegistryKeyIterator;
-  const HKEY root = HKEY_LOCAL_MACHINE;
-  ProgramCompare open_command_pred(
-      installer_state.target_path().Append(kChromeExe));
-  string16 client_open_path;
-  RegKey client_open_key;
-  string16 reg_exe;
-  for (RegistryKeyIterator iter(root, ShellUtil::kRegStartMenuInternet);
-       iter.Valid(); ++iter) {
-    client_open_path.assign(ShellUtil::kRegStartMenuInternet)
-        .append(1, L'\\')
-        .append(iter.Name())
-        .append(ShellUtil::kRegShellOpen);
-    if (client_open_key.Open(root, client_open_path.c_str(),
-                             KEY_QUERY_VALUE) == ERROR_SUCCESS &&
-        client_open_key.ReadValue(L"", &reg_exe) == ERROR_SUCCESS &&
-        open_command_pred.Evaluate(reg_exe)) {
-      return true;
-    }
-  }
-  return false;
-}
-
 // This method deletes Chrome shortcut folder from Windows Start menu. It
 // checks system_uninstall to see if the shortcut is in all users start menu
 // or current user start menu.
 // We try to remove the standard desktop shortcut but if that fails we try
 // to remove the alternate desktop shortcut. Only one of them should be
 // present in a given install but at this point we don't know which one.
 void DeleteChromeShortcuts(const InstallerState& installer_state,
                            const Product& product) {
   if (!product.is_chrome()) {
     VLOG(1) << __FUNCTION__ " called for non-CHROME distribution";
@@ skipping 408 matching lines @@
   // We used to register Chrome to handle crx files, but this turned out
   // to be not worth the hassle. Remove these old registry entries if
   // they exist. See: http://codereview.chromium.org/210007
 
 #if defined(GOOGLE_CHROME_BUILD)
 const wchar_t kChromeExtProgId[] = L"ChromeExt";
 #else
 const wchar_t kChromeExtProgId[] = L"ChromiumExt";
 #endif
 
+  const string16 suffix(ShellUtil::GetCurrentInstallationSuffix());
+
   HKEY roots[] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
   for (size_t i = 0; i < arraysize(roots); ++i) {
-    string16 suffix;
-    if (roots[i] == HKEY_LOCAL_MACHINE &&

[gab, 2012/05/30 00:06:24]

This was introduced in 2009 in
http://src.chromium.org/viewvc/chrome/trunk/src/chrome/installer/setup/uninst...

however the corresponding codereview (http://codereview.chromium.org/210007)
does not have this line.

It's not clear to me why the suffix is only applied for HKLM... can you comment
on this section of the change please.

We can actually probably remove this function entirely given it is doing some
cleanup needed 2.5 years ago...

[gab, 2012/05/30 02:45:31]

Ok, thanks aa@, I'll remove it: https://chromiumcodereview.appspot.com/10454067/

[gab, 2012/05/30 03:16:42]

Actually, as discussed with grt@, we won't remove this (ping me offline for
details).

I modified this CL to reflect exactly the current behavior for this function
with my new set of calls.

-        !ShellUtil::GetUserSpecificDefaultBrowserSuffix(dist, &suffix))
-      suffix = L"";
-
     // Delete Software\Classes\ChromeExt,
     string16 ext_prog_id(ShellUtil::kRegClasses);
     ext_prog_id.push_back(FilePath::kSeparators[0]);
     ext_prog_id.append(kChromeExtProgId);
     ext_prog_id.append(suffix);
     InstallUtil::DeleteRegistryKey(roots[i], ext_prog_id);
 
     // Delete Software\Classes\.crx,
     string16 ext_association(ShellUtil::kRegClasses);
     ext_association.append(L"\\");
@@ skipping 28 matching lines @@
 }
 
 InstallStatus UninstallProduct(const InstallationState& original_state,
                                const InstallerState& installer_state,
                                const FilePath& setup_path,
                                const Product& product,
                                bool remove_all,
                                bool force_uninstall,
                                const CommandLine& cmd_line) {
   InstallStatus status = installer::UNINSTALL_CONFIRMED;
-  string16 suffix;
-  if (!ShellUtil::GetUserSpecificDefaultBrowserSuffix(product.distribution(),
-                                                      &suffix))
-    suffix = L"";
+  BrowserDistribution* browser_dist = product.distribution();
+  const string16 chrome_exe(
+      installer_state.target_path().Append(installer::kChromeExe).value());
 
-  BrowserDistribution* browser_dist = product.distribution();
+  const string16 suffix(ShellUtil::GetCurrentInstallationSuffix());
+
   bool is_chrome = product.is_chrome();
 
   VLOG(1) << "UninstallProduct: " << browser_dist->GetApplicationName();
 
   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.
     // NOTE: We don't do this for Chrome Frame.
     if (is_chrome)
       CloseAllChromeProcesses();
   } else if (is_chrome) {
     // 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;
 
     // 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 &&
-        (!suffix.empty() || CurrentUserHasDefaultBrowser(installer_state)) &&
+    if (ShellUtil::IsInstallationPresentInHKLM(browser_dist, chrome_exe,
+                                               suffix) &&
+        (!suffix.empty() || remove_all) &&
         !::IsUserAnAdmin() &&
         base::win::GetVersion() >= base::win::VERSION_VISTA &&
         !cmd_line.HasSwitch(installer::switches::kRunAsAdmin)) {
       CommandLine new_cmd(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 33 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);
 
   // Remove all Chrome registration keys.
   // Registration data is put in HKCU for both system level and user level
   // installs.
   InstallStatus ret = installer::UNKNOWN_STATUS;
-  DeleteChromeRegistrationKeys(product.distribution(), HKEY_CURRENT_USER,
-                               suffix, installer_state.target_path(), &ret);
+  DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER, suffix,
+                               installer_state.target_path(), &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) and later
+  // had to be suffixed when fully registered in HKLM).
+  // Remove remaining HKCU entries with no suffix if any.
+  if (!suffix.empty()) {
+    DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER, L"",
+                                 installer_state.target_path(), &ret);
+  }
 
   // Chrome is registered in HKLM for all system-level installs and for
   // user-level installs for which Chrome has been made the default browser.
   // Always remove the HKLM registration for system-level installs.  For
-  // user-level installs, only remove it if both: 1) this uninstall isn't a
-  // self-destruct following the installation of system-level Chrome (because
-  // the system-level Chrome owns the HKLM registration now), and 2) this user
-  // had made Chrome their default browser.
-  if (installer_state.system_install() ||
-      (remove_all &&
-       (!suffix.empty() || CurrentUserHasDefaultBrowser(installer_state)))) {
-    DeleteChromeRegistrationKeys(product.distribution(), HKEY_LOCAL_MACHINE,
-                                 suffix, installer_state.target_path(), &ret);
+  // user-level installs, only remove it if either: 1) The registration has a
+  // suffix, or 2) |remove_all| is true which means this is not a self-destruct
+  // following a system-level Chrome install (which would otherwise need the
+  // same HKLM registrations).
+  if (installer_state.system_install() || !suffix.empty() || remove_all) {
+    DeleteChromeRegistrationKeys(browser_dist, HKEY_LOCAL_MACHINE, suffix,
+                                 installer_state.target_path(), &ret);
   }
 
   ProcessDelegateExecuteWorkItems(installer_state, product);
 
   if (!is_chrome) {
     ProcessChromeFrameWorkItems(original_state, installer_state, setup_path,
                                 product);
   }
 
   if (installer_state.is_multi_install())
@@ skipping 113 matching lines @@
 
   // Try and delete the preserved local state once the post-install
   // operations are complete.
   if (!backup_state_file.empty())
     file_util::Delete(backup_state_file, false);
 
   return ret;
 }
 
 }  // namespace installer