Remove Chrome's ProgID from filetype associations at uninstall.

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>
 
@@ skipping 599 matching lines @@
     should_delete = true;
   } else {
     should_delete =
         status == installer::UNINSTALL_DELETE_PROFILE ||
         cmd_line.HasSwitch(installer::switches::kDeleteProfile);
   }
 
   return should_delete;
 }
 
-bool DeleteChromeRegistrationKeys(BrowserDistribution* dist, HKEY root,
+bool DeleteChromeRegistrationKeys(const InstallerState& installer_state,
+                                  BrowserDistribution* dist, HKEY root,

[gab, 2012/09/19 19:58:50]

nit: move "HKEY root" to its own line here too.

[grt (UTC plus 2), 2012/09/19 20:04:52]

Indeed!  Done.

                                   const string16& browser_entry_suffix,
-                                  const FilePath& target_path,
                                   InstallStatus* exit_code) {
   DCHECK(exit_code);
   if (!dist->CanSetAsDefault()) {
     // We should have never set those keys.
     return true;
   }
 
+  const FilePath &target_path(installer_state.target_path());

[gab, 2012/09/19 19:58:50]

|target_path| is only used once, consider inlining it below.

(otherwise => nit: s/FilePath &target_path/FilePath& target_path)

[grt (UTC plus 2), 2012/09/19 20:04:52]

Done.

   FilePath chrome_exe(target_path.Append(kChromeExe));
 
   // Delete Software\Classes\ChromeHTML.
   // For user-level installs we now only write these entries in HKCU, but since
   // old installs did install them to HKLM we will try to remove them in HKLM as
   // well anyways.
   const string16 prog_id(ShellUtil::kChromeHTMLProgId + browser_entry_suffix);
   string16 reg_prog_id(ShellUtil::kRegClasses);
   reg_prog_id.push_back(FilePath::kSeparators[0]);
   reg_prog_id.append(prog_id);
@@ skipping 88 matching lines @@
   // 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, L"",
       InstallUtil::ValueEquals(dist->GetBaseAppName() + browser_entry_suffix));
 
   // Delete each protocol association if it references this Chrome.
   InstallUtil::ProgramCompare open_command_pred(chrome_exe);
   string16 parent_key(ShellUtil::kRegClasses);
+  parent_key.push_back(FilePath::kSeparators[0]);
   const string16::size_type base_length = parent_key.size();
   string16 child_key;
   for (const wchar_t* const* proto =
            &ShellUtil::kPotentialProtocolAssociations[0];
        *proto != NULL;
        ++proto) {
     parent_key.resize(base_length);
-    parent_key.push_back(FilePath::kSeparators[0]);
     parent_key.append(*proto);
     child_key.assign(parent_key).append(ShellUtil::kRegShellOpen);
     InstallUtil::DeleteRegistryKeyIf(root, parent_key, child_key, L"",
                                      open_command_pred);
   }
 
+  // Delete each filetype association if it references this Chrome.  Take care
+  // not to delete the association if it references a system-level install of
+  // Chrome (only a risk if the suffix is empty).  Don't delete the whole key
+  // since other apps may have stored data there.
+  if (!browser_entry_suffix.empty() ||
+      (installer_state.level() == InstallerState::USER_LEVEL &&

[gab, 2012/09/19 19:58:50]

Why not use "!installer_state.system_install()"? That call, on top of being
shorter, has the benefit of making the DCHECK calls to verify |level_| was
initialized I believe.

[grt (UTC plus 2), 2012/09/19 20:04:52]

Done.

+       !base::win::RegKey(HKEY_LOCAL_MACHINE, reg_prog_id.c_str(),
+                          KEY_QUERY_VALUE).Valid())) {
+    InstallUtil::ValueEquals prog_id_pred(prog_id);
+    for (const wchar_t* const* filetype = &ShellUtil::kFileAssociations[0];
+         *filetype != NULL; ++filetype) {
+      parent_key.resize(base_length);
+      parent_key.append(*filetype);
+      InstallUtil::DeleteRegistryValueIf(root, parent_key.c_str(), L"",
+                                         prog_id_pred);
+    }
+  }
+
   // Note that we do not attempt to delete filetype associations since MSDN
   // says "Windows respects the Default value only if the ProgID found there is
   // a registered ProgID. If the ProgID is unregistered, it is ignored."
 
   *exit_code = installer::UNINSTALL_SUCCESSFUL;
   return true;
 }
 
 void RemoveChromeLegacyRegistryKeys(BrowserDistribution* dist,
                                     const string16& chrome_exe) {
@@ skipping 269 matching lines @@
   // 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;
 
   if (is_chrome) {
     // Remove all Chrome registration keys.
     // Registration data is put in HKCU for both system level and user level
     // installs.
-    DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER, suffix,
-                                 installer_state.target_path(), &ret);
+    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
     // is not an admin (or declined UAC at first run)) and later had to be
     // suffixed when fully registered in HKLM (e.g. when later making Chrome
     // default through the UI)).
     // Remove remaining HKCU entries with no suffix if any.
     if (!suffix.empty()) {
-      DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER, string16(),
-                                   installer_state.target_path(), &ret);
+      DeleteChromeRegistrationKeys(installer_state, browser_dist,
+                                   HKEY_CURRENT_USER, string16(), &ret);
 
       // For similar reasons it is possible in very few installs (from
       // 21.0.1180.0 and fixed shortly after) to be installed with the new-style
       // suffix, but have some old-style suffix registrations left behind.
       string16 old_style_suffix;
       if (ShellUtil::GetOldUserSpecificRegistrySuffix(&old_style_suffix) &&
           suffix != old_style_suffix) {
-        DeleteChromeRegistrationKeys(browser_dist, HKEY_CURRENT_USER,
-                                     old_style_suffix,
-                                     installer_state.target_path(), &ret);
+        DeleteChromeRegistrationKeys(installer_state, browser_dist,
+                                     HKEY_CURRENT_USER, old_style_suffix, &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 a system-level Chrome
     // (because the system-level Chrome owns the HKLM registration now), and 2)
     // this user has made Chrome their default browser (i.e. has shell
     // 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))) {
-      DeleteChromeRegistrationKeys(browser_dist, HKEY_LOCAL_MACHINE, suffix,
-                                   installer_state.target_path(), &ret);
+      DeleteChromeRegistrationKeys(installer_state, browser_dist,
+                                   HKEY_LOCAL_MACHINE, suffix, &ret);
     }
 
     ProcessDelegateExecuteWorkItems(installer_state, product);
 
     ProcessOnOsUpgradeWorkItems(installer_state, product);
 
 // TODO(gab): This is only disabled for M22 as the shortcut CL using Active
 // Setup will not make it in M22.
 #if 0
     UninstallActiveSetupEntries(installer_state, product);
 #endif
+
+    // Notify the shell that associations have changed since Chrome was likely
+    // unregistered.
+    SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
   }
 
   if (product.is_chrome_frame()) {
     ProcessChromeFrameWorkItems(original_state, installer_state, setup_path,
                                 product);
   }
 
   if (installer_state.is_multi_install())
     ProcessGoogleUpdateItems(original_state, installer_state, product);
 
@@ skipping 96 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