Add WOW64 support to the installer registry work items

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 28 matching lines @@
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/installer/util/self_cleaning_temp_dir.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
+#include "chrome/installer/util/work_item.h"
 #include "content/public/common/result_codes.h"
 #include "rlz/lib/rlz_lib.h"
 
 using base::win::RegKey;
 
 namespace installer {
 
 namespace {
 
 // Avoid leaving behind a Temp dir.  If one exists, ask SelfCleaningTempDir to
@@ skipping 28 matching lines @@
   for (size_t i = 0; i < dist_types.size(); ++i) {
     BrowserDistribution::Type dist_type = dist_types[i];
     const ProductState* product_state =
         original_state.GetProductState(system_level, dist_type);
     // Only modify other products if they're installed and multi.
     if (product_state != NULL &&
         product_state->is_multi_install() &&
         !product_state->channel().Equals(channel_info)) {
       BrowserDistribution* other_dist =
           BrowserDistribution::GetSpecificDistribution(dist_type);
-      update_list->AddSetRegValueWorkItem(reg_root, other_dist->GetStateKey(),
-          google_update::kRegApField, channel_info.value(), true);
+      update_list->AddSetRegValueWorkItem(reg_root,
+                                          other_dist->GetStateKey(),
+                                          WorkItem::kWow64Default,
+                                          google_update::kRegApField,
+                                          channel_info.value(),
+                                          true);
     } else {
       LOG_IF(ERROR,
              product_state != NULL && product_state->is_multi_install())
           << "Channel value for "
           << BrowserDistribution::GetSpecificDistribution(
                  dist_type)->GetDisplayName()
           << " is somehow already set to the desired new value of "
           << channel_info.value();
     }
   }
@@ skipping 564 matching lines @@
   std::vector<const wchar_t*> cleared_assocs;
   if (installer_state.system_install() ||
       !browser_entry_suffix.empty() ||
       !base::win::RegKey(HKEY_LOCAL_MACHINE, (classes_path + prog_id).c_str(),
                          KEY_QUERY_VALUE).Valid()) {
     InstallUtil::ValueEquals prog_id_pred(prog_id);
     for (const wchar_t* const* filetype =
          &ShellUtil::kPotentialFileAssociations[0]; *filetype != NULL;
          ++filetype) {
       if (InstallUtil::DeleteRegistryValueIf(
-              root, (classes_path + *filetype).c_str(), NULL,
-              prog_id_pred) == InstallUtil::DELETED) {
+              root, (classes_path + *filetype).c_str(), WorkItem::kWow64Default,
+              NULL, prog_id_pred) == InstallUtil::DELETED) {
         cleared_assocs.push_back(*filetype);
       }
     }
   }
 
   // For all filetype associations in HKLM that have just been removed, attempt
   // to restore some reasonable value.  We have no definitive way of knowing
   // what handlers are the most appropriate, so we use a fixed mapping based on
   // the default values for a fresh install of Windows.
   if (root == HKEY_LOCAL_MACHINE) {
@@ skipping 53 matching lines @@
   if (!product.is_chrome() || !installer_state.system_install()) {
     const char* install_level =
         installer_state.system_install() ? "system" : "user";
     VLOG(1) << "No Active Setup processing to do for " << install_level
             << "-level " << distribution->GetDisplayName();
     return;
   }
 
   const base::string16 active_setup_path(
       InstallUtil::GetActiveSetupPath(distribution));
-  InstallUtil::DeleteRegistryKey(HKEY_LOCAL_MACHINE, active_setup_path);
+  InstallUtil::DeleteRegistryKey(HKEY_LOCAL_MACHINE, active_setup_path,
+                                 WorkItem::kWow64Default);
 
   // Windows leaves keys behind in HKCU\\Software\\(Wow6432Node\\)?Microsoft\\
   //     Active Setup\\Installed Components\\{guid}
   // for every user that logged in since system-level Chrome was installed.
   // This is a problem because Windows compares the value of the Version subkey
   // in there with the value of the Version subkey in the matching HKLM entries
   // before running Chrome's Active Setup so if Chrome was to be reinstalled
   // with a lesser version (e.g. switching back to a more stable channel), the
   // affected users would not have Chrome's Active Setup called until Chrome
   // eventually updated passed that user's registered Version.
@@ skipping 125 matching lines @@
   }
 
   base::FilePath chrome_exe(installer_state.target_path().Append(kChromeExe));
 
   // Delete Software\Classes\ChromeHTML.
   const base::string16 prog_id(
       dist->GetBrowserProgIdPrefix() + browser_entry_suffix);
   base::string16 reg_prog_id(ShellUtil::kRegClasses);
   reg_prog_id.push_back(base::FilePath::kSeparators[0]);
   reg_prog_id.append(prog_id);
-  InstallUtil::DeleteRegistryKey(root, reg_prog_id);
+  InstallUtil::DeleteRegistryKey(root, reg_prog_id, WorkItem::kWow64Default);
 
   // Delete Software\Classes\Chrome.
   base::string16 reg_app_id(ShellUtil::kRegClasses);
   reg_app_id.push_back(base::FilePath::kSeparators[0]);
   // Append the requested suffix manually here (as ShellUtil::GetBrowserModelId
   // would otherwise try to figure out the currently installed suffix).
   reg_app_id.append(dist->GetBaseAppId() + browser_entry_suffix);
-  InstallUtil::DeleteRegistryKey(root, reg_app_id);
+  InstallUtil::DeleteRegistryKey(root, reg_app_id, WorkItem::kWow64Default);
 
   // Delete all Start Menu Internet registrations that refer to this Chrome.
   {
     using base::win::RegistryKeyIterator;
     InstallUtil::ProgramCompare open_command_pred(chrome_exe);
     base::string16 client_name;
     base::string16 client_key;
     base::string16 open_key;
     for (RegistryKeyIterator iter(root, ShellUtil::kRegStartMenuInternet);
          iter.Valid(); ++iter) {
       client_name.assign(iter.Name());
       client_key.assign(ShellUtil::kRegStartMenuInternet)
           .append(1, L'\\')
           .append(client_name);
       open_key.assign(client_key).append(ShellUtil::kRegShellOpen);
-      if (InstallUtil::DeleteRegistryKeyIf(root, client_key, open_key, NULL,
-              open_command_pred) != InstallUtil::NOT_FOUND) {
+      if (InstallUtil::DeleteRegistryKeyIf(root, client_key, open_key,
+              WorkItem::kWow64Default, NULL, open_command_pred)
+                  != InstallUtil::NOT_FOUND) {
         // Delete the default value of SOFTWARE\Clients\StartMenuInternet if it
         // references this Chrome (i.e., if it was made the default browser).
         InstallUtil::DeleteRegistryValueIf(
-            root, ShellUtil::kRegStartMenuInternet, NULL,
-            InstallUtil::ValueEquals(client_name));
+            root, ShellUtil::kRegStartMenuInternet, WorkItem::kWow64Default,
+            NULL, InstallUtil::ValueEquals(client_name));
         // Also delete the value for the default user if we're operating in
         // HKLM.
         if (root == HKEY_LOCAL_MACHINE) {
           InstallUtil::DeleteRegistryValueIf(
               HKEY_USERS,
               base::string16(L".DEFAULT\\").append(
                   ShellUtil::kRegStartMenuInternet).c_str(),
-              NULL, InstallUtil::ValueEquals(client_name));
+              WorkItem::kWow64Default, NULL,
+              InstallUtil::ValueEquals(client_name));
         }
       }
     }
   }
 
   // Delete Software\RegisteredApplications\Chromium
   InstallUtil::DeleteRegistryValue(
       root, ShellUtil::kRegRegisteredApplications,
+      WorkItem::kWow64Default,
       dist->GetBaseAppName() + 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);
+  InstallUtil::DeleteRegistryKey(root, app_key, WorkItem::kWow64Default);
 
   base::string16 app_path_key(ShellUtil::kAppPathsRegistryKey);
   app_path_key.push_back(base::FilePath::kSeparators[0]);
   app_path_key.append(installer::kChromeExe);
-  InstallUtil::DeleteRegistryKey(root, app_path_key);
+  InstallUtil::DeleteRegistryKey(root, app_path_key, WorkItem::kWow64Default);
 
   // Cleanup OpenWithList and OpenWithProgids:
   // http://msdn.microsoft.com/en-us/library/bb166549
   base::string16 file_assoc_key;
   base::string16 open_with_list_key;
   base::string16 open_with_progids_key;
   for (int i = 0; ShellUtil::kPotentialFileAssociations[i] != NULL; ++i) {
     file_assoc_key.assign(ShellUtil::kRegClasses);
     file_assoc_key.push_back(base::FilePath::kSeparators[0]);
     file_assoc_key.append(ShellUtil::kPotentialFileAssociations[i]);
     file_assoc_key.push_back(base::FilePath::kSeparators[0]);
 
     open_with_list_key.assign(file_assoc_key);
     open_with_list_key.append(L"OpenWithList");
     open_with_list_key.push_back(base::FilePath::kSeparators[0]);
     open_with_list_key.append(installer::kChromeExe);
-    InstallUtil::DeleteRegistryKey(root, open_with_list_key);
+    InstallUtil::DeleteRegistryKey(
+        root, open_with_list_key, WorkItem::kWow64Default);
 
     open_with_progids_key.assign(file_assoc_key);
     open_with_progids_key.append(ShellUtil::kRegOpenWithProgids);
-    InstallUtil::DeleteRegistryValue(root, open_with_progids_key, prog_id);
+    InstallUtil::DeleteRegistryValue(root, open_with_progids_key,
+                                     WorkItem::kWow64Default, prog_id);
   }
 
   // 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, NULL,
+      root, ShellUtil::kRegStartMenuInternet, WorkItem::kWow64Default, NULL,
       InstallUtil::ValueEquals(dist->GetBaseAppName() + 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;
        ++proto) {
     parent_key.resize(base_length);
     parent_key.append(*proto);
     child_key.assign(parent_key).append(ShellUtil::kRegShellOpen);
-    InstallUtil::DeleteRegistryKeyIf(root, parent_key, child_key, NULL,
+    InstallUtil::DeleteRegistryKeyIf(root, parent_key, child_key,
+                                     WorkItem::kWow64Default, NULL,
                                      open_command_pred);
   }
 
   RemoveFiletypeRegistration(installer_state, root, browser_entry_suffix);
 
   *exit_code = installer::UNINSTALL_SUCCESSFUL;
   return true;
 }
 
 void RemoveChromeLegacyRegistryKeys(BrowserDistribution* dist,
@@ skipping 12 matching lines @@
   for (size_t i = 0; i < arraysize(roots); ++i) {
     base::string16 suffix;
     if (roots[i] == HKEY_LOCAL_MACHINE)
       suffix = ShellUtil::GetCurrentInstallationSuffix(dist, 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);
+    InstallUtil::DeleteRegistryKey(roots[i], ext_prog_id,
+                                   WorkItem::kWow64Default);
 
     // Delete Software\Classes\.crx,
     base::string16 ext_association(ShellUtil::kRegClasses);
     ext_association.append(L"\\");
     ext_association.append(L".crx");
-    InstallUtil::DeleteRegistryKey(roots[i], ext_association);
+    InstallUtil::DeleteRegistryKey(roots[i], ext_association,
+                                   WorkItem::kWow64Default);
   }
 }
 
 void UninstallFirewallRules(BrowserDistribution* dist,
                             const base::FilePath& chrome_exe) {
   scoped_ptr<FirewallManager> manager =
       FirewallManager::Create(dist, chrome_exe);
   if (manager)
     manager->RemoveFirewallRules();
 }
@@ skipping 59 matching lines @@
   }
 
   if (is_chrome) {
     // Chrome is not in use so lets uninstall Chrome by deleting various files
     // and registry entries. Here we will just make best effort and keep going
     // in case of errors.
     ClearRlzProductState();
     // Delete the key that delegate_execute might make.
     if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
       InstallUtil::DeleteRegistryKey(HKEY_CURRENT_USER,
-                                     chrome::kMetroRegistryPath);
+                                     chrome::kMetroRegistryPath,
+                                     WorkItem::kWow64Default);
     }
 
     auto_launch_util::DisableAllAutoStartFeatures(
         base::ASCIIToUTF16(chrome::kInitialProfile));
 
     // If user-level chrome is self-destructing as a result of encountering a
     // system-level chrome, retarget owned non-default shortcuts (app shortcuts,
     // profile shortcuts, etc.) to the system-level chrome.
     if (cmd_line.HasSwitch(installer::switches::kSelfDestruct) &&
         !installer_state.system_install()) {
@@ skipping 16 matching lines @@
   // Delete the registry keys (Uninstall key and Version key).
   HKEY reg_root = installer_state.root_key();
 
   // Note that we must retrieve the distribution-specific data before deleting
   // product.GetVersionKey().
   base::string16 distribution_data(browser_dist->GetDistributionData(reg_root));
 
   // Remove Control Panel uninstall link.
   if (product.ShouldCreateUninstallEntry()) {
     InstallUtil::DeleteRegistryKey(reg_root,
-                                   browser_dist->GetUninstallRegPath());
+                                   browser_dist->GetUninstallRegPath(),
+                                   WorkItem::kWow64Default);
   }
 
   // Remove Omaha product key.
-  InstallUtil::DeleteRegistryKey(reg_root, browser_dist->GetVersionKey());
+  InstallUtil::DeleteRegistryKey(reg_root, browser_dist->GetVersionKey(),
+                                 WorkItem::kWow64Default);
 
   // 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;
 
   if (is_chrome) {
@@ skipping 71 matching lines @@
       chrome_launcher_support::InstallationState level_to_check =
           installer_state.system_install() ?
               chrome_launcher_support::INSTALLED_AT_SYSTEM_LEVEL :
               chrome_launcher_support::INSTALLED_AT_USER_LEVEL;
       bool has_legacy_app_launcher = level_to_check ==
           chrome_launcher_support::GetAppLauncherInstallationState();
       if (!has_legacy_app_launcher) {
         BrowserDistribution* shadow_app_launcher_dist =
             BrowserDistribution::GetSpecificDistribution(
                 BrowserDistribution::CHROME_APP_HOST);
-        InstallUtil::DeleteRegistryKey(reg_root,
-            shadow_app_launcher_dist->GetVersionKey());
+        InstallUtil::DeleteRegistryKey(
+            reg_root,
+            shadow_app_launcher_dist->GetVersionKey(),
+            WorkItem::kWow64Default);
       }
     }
   }
 
   if (installer_state.is_multi_install())
     ProcessGoogleUpdateItems(original_state, installer_state, product);
 
   // Get the state of the installed product (if any)
   const ProductState* product_state =
       original_state.GetProductState(installer_state.system_install(),
                                      browser_dist->GetType());
 
   // Delete shared registry keys as well (these require admin rights) if
   // remove_all option is specified.
   if (remove_all) {
     if (!InstallUtil::IsChromeSxSProcess() && is_chrome) {
       // Delete media player registry key that exists only in HKLM.
       // We don't delete this key in SxS uninstall or Chrome Frame uninstall
       // as we never set the key for those products.
       base::string16 reg_path(installer::kMediaPlayerRegPath);
       reg_path.push_back(base::FilePath::kSeparators[0]);
       reg_path.append(installer::kChromeExe);
-      InstallUtil::DeleteRegistryKey(HKEY_LOCAL_MACHINE, reg_path);
+      InstallUtil::DeleteRegistryKey(HKEY_LOCAL_MACHINE, reg_path,
+                                     WorkItem::kWow64Default);
     }
 
     // Unregister any dll servers that we may have registered for this
     // product.
     if (product_state != NULL) {
       std::vector<base::FilePath> com_dll_list;
       product.AddComDllList(&com_dll_list);
       base::FilePath dll_folder = installer_state.target_path().AppendASCII(
           product_state->version().GetString());
 
@@ skipping 139 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