Make omaha, gcapi and uninstall registry accesses use Wow6432Node on 64-bit

chrome/installer/setup/install_worker.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 contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <oaidl.h>
@@ skipping 198 matching lines @@
   DCHECK(app);
   DCHECK(command_with_parameter);
   DCHECK(work_item_list);
 
   base::string16 full_cmd_key(
       GetRegCommandKey(product.distribution(), command_key));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     work_item_list->AddDeleteRegKeyWorkItem(installer_state.root_key(),
                                             full_cmd_key,
-                                            WorkItem::kWow64Default)
+                                            KEY_WOW64_32KEY)
         ->set_log_message("removing " + base::UTF16ToASCII(command_key) +
                           " command");
   } else {
     CommandLine cmd_line(installer_state.target_path().Append(app));
     cmd_line.AppendSwitchASCII(command_with_parameter, "%1");
 
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_sends_pings(true);
     cmd.set_is_web_accessible(true);
     cmd.set_is_run_as_user(true);
@@ skipping 205 matching lines @@
     const base::FilePath& temp_path,
     WorkItemList* work_item_list) {
   DCHECK(installer_state.is_msi())
       << "This must only be called for MSI installations!";
 
   // First attempt to delete the old installation's ARP dialog entry.
   HKEY reg_root = installer_state.root_key();
   base::string16 uninstall_reg(product.distribution()->GetUninstallRegPath());
 
   WorkItem* delete_reg_key = work_item_list->AddDeleteRegKeyWorkItem(
-      reg_root, uninstall_reg, WorkItem::kWow64Default);
+      reg_root, uninstall_reg, KEY_WOW64_32KEY);
   delete_reg_key->set_ignore_failure(true);
 
   // Then attempt to delete the old installation's start menu shortcut.
   base::FilePath uninstall_link;
   if (installer_state.system_install()) {
     PathService::Get(base::DIR_COMMON_START_MENU, &uninstall_link);
   } else {
     PathService::Get(base::DIR_START_MENU, &uninstall_link);
   }
 
@@ skipping 148 matching lines @@
 
   return true;
 }
 
 void AddUninstallDelegateExecuteWorkItems(
     HKEY root,
     const base::string16& delegate_execute_path,
     WorkItemList* list) {
   VLOG(1) << "Adding unregistration items for DelegateExecute verb handler in "
           << root;
-  list->AddDeleteRegKeyWorkItem(root,
-                                delegate_execute_path,
-                                WorkItem::kWow64Default);
+  // Delete both 64 and 32 keys to handle 32->64 or 64->32 migration.
+  list->AddDeleteRegKeyWorkItem(root, delegate_execute_path, KEY_WOW64_32KEY);
+
+  list->AddDeleteRegKeyWorkItem(root, delegate_execute_path, KEY_WOW64_64KEY);
 
   // In the past, the ICommandExecuteImpl interface and a TypeLib were both
   // registered.  Remove these since this operation may be updating a machine
   // that had the old registrations.
   list->AddDeleteRegKeyWorkItem(root,
                                 L"Software\\Classes\\Interface\\"
                                 L"{0BA0D4E9-2259-4963-B9AE-A839F7CB7544}",
-                                WorkItem::kWow64Default);
+                                KEY_WOW64_32KEY);
   list->AddDeleteRegKeyWorkItem(root,
                                 L"Software\\Classes\\TypeLib\\"
 #if defined(GOOGLE_CHROME_BUILD)
                                 L"{4E805ED8-EBA0-4601-9681-12815A56EBFD}",
 #else
                                 L"{7779FB70-B399-454A-AA1A-BAA850032B10}",
 #endif
-                                WorkItem::kWow64Default);
+                                KEY_WOW64_32KEY);
 }
 
 // Google Chrome Canary, between 20.0.1101.0 (crrev.com/132190) and 20.0.1106.0
 // (exclusively -- crrev.com/132596), registered a DelegateExecute class by
 // mistake (with the same GUID as Chrome). The fix stopped registering the bad
 // value, but didn't delete it. This is a problem for users who had installed
 // Canary before 20.0.1106.0 and now have a system-level Chrome, as the
 // left-behind Canary registrations in HKCU mask the HKLM registrations for the
 // same GUID. Cleanup those registrations if they still exist and belong to this
 // Canary (i.e., the registered delegate_execute's path is under |target_path|).
@@ skipping 49 matching lines @@
   base::FilePath installer_path(
       installer_state.GetInstallerDirectory(new_version));
   installer_path = installer_path.Append(setup_path.BaseName());
 
   CommandLine uninstall_arguments(CommandLine::NO_PROGRAM);
   AppendUninstallCommandLineFlags(installer_state, product,
                                   &uninstall_arguments);
 
   base::string16 update_state_key(browser_dist->GetStateKey());
   install_list->AddCreateRegKeyWorkItem(
-      reg_root, update_state_key, WorkItem::kWow64Default);
+      reg_root, update_state_key, KEY_WOW64_32KEY);
   install_list->AddSetRegValueWorkItem(reg_root,
                                        update_state_key,
-                                       WorkItem::kWow64Default,
+                                       KEY_WOW64_32KEY,
                                        installer::kUninstallStringField,
                                        installer_path.value(),
                                        true);
   install_list->AddSetRegValueWorkItem(
       reg_root,
       update_state_key,
-      WorkItem::kWow64Default,
+      KEY_WOW64_32KEY,
       installer::kUninstallArgumentsField,
       uninstall_arguments.GetCommandLineString(),
       true);
 
   // MSI installations will manage their own uninstall shortcuts.
   if (!installer_state.is_msi() && product.ShouldCreateUninstallEntry()) {
     // We need to quote the command line for the Add/Remove Programs dialog.
     CommandLine quoted_uninstall_cmd(installer_path);
     DCHECK_EQ(quoted_uninstall_cmd.GetCommandLineString()[0], '"');
     quoted_uninstall_cmd.AppendArguments(uninstall_arguments, false);
 
     base::string16 uninstall_reg = browser_dist->GetUninstallRegPath();
     install_list->AddCreateRegKeyWorkItem(
-        reg_root, uninstall_reg, WorkItem::kWow64Default);
+        reg_root, uninstall_reg, KEY_WOW64_32KEY);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          installer::kUninstallDisplayNameField,
                                          browser_dist->GetDisplayName(),
                                          true);
     install_list->AddSetRegValueWorkItem(
         reg_root,
         uninstall_reg,
-        WorkItem::kWow64Default,
+        KEY_WOW64_32KEY,
         installer::kUninstallStringField,
         quoted_uninstall_cmd.GetCommandLineString(),
         true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"InstallLocation",
                                          install_path.value(),
                                          true);
 
     BrowserDistribution* dist = product.distribution();
     base::string16 chrome_icon = ShellUtil::FormatIconLocation(
         install_path.Append(dist->GetIconFilename()).value(),
         dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME));
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"DisplayIcon",
                                          chrome_icon,
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"NoModify",
                                          static_cast<DWORD>(1),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"NoRepair",
                                          static_cast<DWORD>(1),
                                          true);
 
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"Publisher",
                                          browser_dist->GetPublisherName(),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"Version",
                                          ASCIIToWide(new_version.GetString()),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"DisplayVersion",
                                          ASCIIToWide(new_version.GetString()),
                                          true);
+    // TODO(wfh): Ensure that this value is preserved in the 64-bit hive when
+    // 64-bit installs place the uninstall information into the 64-bit registry.
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"InstallDate",
                                          InstallUtil::GetCurrentDate(),
                                          false);
 
     const std::vector<uint16>& version_components = new_version.components();
     if (version_components.size() == 4) {
       // Our version should be in major.minor.build.rev.
       install_list->AddSetRegValueWorkItem(
           reg_root,
           uninstall_reg,
-          WorkItem::kWow64Default,
+          KEY_WOW64_32KEY,
           L"VersionMajor",
           static_cast<DWORD>(version_components[2]),
           true);
       install_list->AddSetRegValueWorkItem(
           reg_root,
           uninstall_reg,
-          WorkItem::kWow64Default,
+          KEY_WOW64_32KEY,
           L"VersionMinor",
           static_cast<DWORD>(version_components[3]),
           true);
     }
   }
 }
 
 // Create Version key for a product (if not already present) and sets the new
 // product version as the last step.
 void AddVersionKeyWorkItems(HKEY root,
                             BrowserDistribution* dist,
                             const Version& new_version,
                             bool add_language_identifier,
                             WorkItemList* list) {
   // Create Version key for each distribution (if not already present) and set
   // the new product version as the last step.
   base::string16 version_key(dist->GetVersionKey());
-  list->AddCreateRegKeyWorkItem(root, version_key, WorkItem::kWow64Default);
+  list->AddCreateRegKeyWorkItem(root, version_key, KEY_WOW64_32KEY);
 
   base::string16 product_name(dist->GetDisplayName());
   list->AddSetRegValueWorkItem(root,
                                version_key,
-                               WorkItem::kWow64Default,
+                               KEY_WOW64_32KEY,
                                google_update::kRegNameField,
                                product_name,
                                true);  // overwrite name also
   list->AddSetRegValueWorkItem(root,
                                version_key,
-                               WorkItem::kWow64Default,
+                               KEY_WOW64_32KEY,
                                google_update::kRegOopcrashesField,
                                static_cast<DWORD>(1),
                                false);  // set during first install
   if (add_language_identifier) {
     // Write the language identifier of the current translation.  Omaha's set of
     // languages is a superset of Chrome's set of translations with this one
     // exception: what Chrome calls "en-us", Omaha calls "en".  sigh.
     base::string16 language(GetCurrentTranslation());
     if (LowerCaseEqualsASCII(language, "en-us"))
       language.resize(2);
     list->AddSetRegValueWorkItem(root,
                                  version_key,
-                                 WorkItem::kWow64Default,
+                                 KEY_WOW64_32KEY,
                                  google_update::kRegLangField,
                                  language,
                                  false);  // do not overwrite language
   }
   list->AddSetRegValueWorkItem(root,
                                version_key,
-                               WorkItem::kWow64Default,
+                               KEY_WOW64_32KEY,
                                google_update::kRegVersionField,
                                ASCIIToWide(new_version.GetString()),
                                true);  // overwrite version
 }
 
 // Mirror oeminstall the first time anything is installed multi.  There is no
 // need to update the value on future install/update runs since this value never
 // changes.  Note that the value is removed by Google Update after EULA
 // acceptance is processed.
 void AddOemInstallWorkItems(const InstallationState& original_state,
@@ skipping 22 matching lines @@
     }
     const ProductState* source_product =
         original_state.GetNonVersionedProductState(system_install, source_type);
 
     base::string16 oem_install;
     if (source_product->GetOemInstall(&oem_install)) {
       VLOG(1) << "Mirroring oeminstall=\"" << oem_install << "\" from "
               << BrowserDistribution::GetSpecificDistribution(source_type)->
                      GetDisplayName();
       install_list->AddCreateRegKeyWorkItem(
-          root_key, multi_key, WorkItem::kWow64Default);
+          root_key, multi_key, KEY_WOW64_32KEY);
       // Always overwrite an old value.
       install_list->AddSetRegValueWorkItem(root_key,
                                            multi_key,
-                                           WorkItem::kWow64Default,
+                                           KEY_WOW64_32KEY,
                                            google_update::kRegOemInstallField,
                                            oem_install,
                                            true);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
           root_key,
           multi_key,
-          WorkItem::kWow64Default,
+          KEY_WOW64_32KEY,
           google_update::kRegOemInstallField);
     }
   }
 }
 
 // Mirror eulaaccepted the first time anything is installed multi.  There is no
 // need to update the value on future install/update runs since
 // GoogleUpdateSettings::SetEULAConsent will modify the value for both the
 // relevant product and for the binaries.
 void AddEulaAcceptedWorkItems(const InstallationState& original_state,
@@ skipping 28 matching lines @@
         eula_accepted = dword_value;
         product_type = this_type;
       }
     }
 
     if (have_eula_accepted) {
       VLOG(1) << "Mirroring eulaaccepted=" << eula_accepted << " from "
               << BrowserDistribution::GetSpecificDistribution(product_type)->
                      GetDisplayName();
       install_list->AddCreateRegKeyWorkItem(
-          root_key, multi_key, WorkItem::kWow64Default);
+          root_key, multi_key, KEY_WOW64_32KEY);
       install_list->AddSetRegValueWorkItem(root_key,
                                            multi_key,
-                                           WorkItem::kWow64Default,
+                                           KEY_WOW64_32KEY,
                                            google_update::kRegEULAAceptedField,
                                            eula_accepted,
                                            true);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
           root_key,
           multi_key,
-          WorkItem::kWow64Default,
+          KEY_WOW64_32KEY,
           google_update::kRegEULAAceptedField);
     }
   }
 }
 
 // Adds work items that make registry adjustments for Google Update.
 void AddGoogleUpdateWorkItems(const InstallationState& original_state,
                               const InstallerState& installer_state,
                               WorkItemList* install_list) {
   // Is a multi-install product being installed or over-installed?
   if (installer_state.operation() != InstallerState::MULTI_INSTALL &&
       installer_state.operation() != InstallerState::MULTI_UPDATE) {
     VLOG(1) << "AddGoogleUpdateWorkItems noop: " << installer_state.operation();
     return;
   }
 
   const bool system_install = installer_state.system_install();
   const HKEY root_key = installer_state.root_key();
   base::string16 multi_key(
       installer_state.multi_package_binaries_distribution()->GetStateKey());
 
   // For system-level installs, make sure the ClientStateMedium key for the
   // binaries exists.
   if (system_install) {
     install_list->AddCreateRegKeyWorkItem(
         root_key,
         installer_state.multi_package_binaries_distribution()
-            ->GetStateMediumKey().c_str(),
-        WorkItem::kWow64Default);
+            ->GetStateMediumKey()
+            .c_str(),
+        KEY_WOW64_32KEY);
   }
 
   // Creating the ClientState key for binaries, if we're migrating to multi then
   // copy over Chrome's brand code if it has one.
   if (installer_state.state_type() != BrowserDistribution::CHROME_BINARIES) {
     const ProductState* chrome_product_state =
         original_state.GetNonVersionedProductState(
             system_install, BrowserDistribution::CHROME_BROWSER);
 
     const base::string16& brand(chrome_product_state->brand());
     if (!brand.empty()) {
       install_list->AddCreateRegKeyWorkItem(
-          root_key, multi_key, WorkItem::kWow64Default);
+          root_key, multi_key, KEY_WOW64_32KEY);
       // Write Chrome's brand code to the multi key. Never overwrite the value
       // if one is already present (although this shouldn't happen).
       install_list->AddSetRegValueWorkItem(root_key,
                                            multi_key,
-                                           WorkItem::kWow64Default,
+                                           KEY_WOW64_32KEY,
                                            google_update::kRegBrandField,
                                            brand,
                                            false);
     }
   }
 
   AddOemInstallWorkItems(original_state, installer_state, install_list);
   AddEulaAcceptedWorkItems(original_state, installer_state, install_list);
   AddUsageStatsWorkItems(original_state, installer_state, install_list);
 
@@ skipping 22 matching lines @@
         original_state.GetNonVersionedProductState(
             installer_state.system_install(), dist->GetType());
     value_found = product_state->GetUsageStats(&usagestats);
   }
 
   // If a value was found, write it in the appropriate location for the
   // binaries and remove all values from the products.
   if (value_found) {
     base::string16 state_key(
         installer_state.multi_package_binaries_distribution()->GetStateKey());
-    install_list->AddCreateRegKeyWorkItem(
-        root_key, state_key, WorkItem::kWow64Default);
+    install_list->AddCreateRegKeyWorkItem(root_key, state_key, KEY_WOW64_32KEY);
     // Overwrite any existing value so that overinstalls (where Omaha writes a
     // new value into a product's state key) pick up the correct value.
     install_list->AddSetRegValueWorkItem(root_key,
                                          state_key,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          google_update::kRegUsageStatsField,
                                          usagestats,
                                          true);
 
     for (Products::const_iterator scan = products.begin(), end = products.end();
          scan != end; ++scan) {
       if ((*scan)->is_chrome_binaries())
         continue;
       BrowserDistribution* dist = (*scan)->distribution();
       if (installer_state.system_install()) {
         install_list->AddDeleteRegValueWorkItem(
             root_key,
             dist->GetStateMediumKey(),
-            WorkItem::kWow64Default,
+            KEY_WOW64_32KEY,
             google_update::kRegUsageStatsField);
         // Previous versions of Chrome also wrote a value in HKCU even for
         // system-level installs, so clean that up.
         install_list->AddDeleteRegValueWorkItem(
             HKEY_CURRENT_USER,
             dist->GetStateKey(),
-            WorkItem::kWow64Default,
+            KEY_WOW64_32KEY,
             google_update::kRegUsageStatsField);
       }
       install_list->AddDeleteRegValueWorkItem(
           root_key,
           dist->GetStateKey(),
-          WorkItem::kWow64Default,
+          KEY_WOW64_32KEY,
           google_update::kRegUsageStatsField);
     }
   }
 }
 
 bool AppendPostInstallTasks(const InstallerState& installer_state,
                             const base::FilePath& setup_path,
                             const Version* current_version,
                             const Version& new_version,
                             const base::FilePath& temp_path,
@@ skipping 33 matching lines @@
 
     base::string16 version_key;
     for (size_t i = 0; i < products.size(); ++i) {
       BrowserDistribution* dist = products[i]->distribution();
       version_key = dist->GetVersionKey();
 
       if (current_version) {
         in_use_update_work_items->AddSetRegValueWorkItem(
             root,
             version_key,
-            WorkItem::kWow64Default,
+            KEY_WOW64_32KEY,
             google_update::kRegOldVersionField,
             ASCIIToWide(current_version->GetString()),
             true);
       }
       if (critical_version.IsValid()) {
         in_use_update_work_items->AddSetRegValueWorkItem(
             root,
             version_key,
-            WorkItem::kWow64Default,
+            KEY_WOW64_32KEY,
             google_update::kRegCriticalVersionField,
             ASCIIToWide(critical_version.GetString()),
             true);
       } else {
         in_use_update_work_items->AddDeleteRegValueWorkItem(
             root,
             version_key,
-            WorkItem::kWow64Default,
+            KEY_WOW64_32KEY,
             google_update::kRegCriticalVersionField);
       }
 
       // Adding this registry entry for all products (but the binaries) is
       // overkill. However, as it stands, we don't have a way to know which
       // product will check the key and run the command, so we add it for all.
       // The first to run it will perform the operation and clean up the other
       // values.
       if (dist->GetType() != BrowserDistribution::CHROME_BINARIES) {
         CommandLine product_rename_cmd(rename);
         products[i]->AppendRenameFlags(&product_rename_cmd);
         in_use_update_work_items->AddSetRegValueWorkItem(
             root,
             version_key,
-            WorkItem::kWow64Default,
+            KEY_WOW64_32KEY,
             google_update::kRegRenameCmdField,
             product_rename_cmd.GetCommandLineString(),
             true);
       }
     }
 
     post_install_task_list->AddWorkItem(in_use_update_work_items.release());
   }
 
   // Append work items that will be executed if this was NOT an in-use update.
   {
     scoped_ptr<WorkItemList> regular_update_work_items(
         WorkItem::CreateConditionalWorkItemList(
             new Not(new ConditionRunIfFileExists(new_chrome_exe))));
     regular_update_work_items->set_log_message("RegularUpdateWorkItemList");
 
     // Since this was not an in-use-update, delete 'opv', 'cpv', and 'cmd' keys.
     for (size_t i = 0; i < products.size(); ++i) {
       BrowserDistribution* dist = products[i]->distribution();
       base::string16 version_key(dist->GetVersionKey());
       regular_update_work_items->AddDeleteRegValueWorkItem(
           root,
           version_key,
-          WorkItem::kWow64Default,
+          KEY_WOW64_32KEY,
           google_update::kRegOldVersionField);
       regular_update_work_items->AddDeleteRegValueWorkItem(
           root,
           version_key,
-          WorkItem::kWow64Default,
+          KEY_WOW64_32KEY,
           google_update::kRegCriticalVersionField);
       regular_update_work_items->AddDeleteRegValueWorkItem(
           root,
           version_key,
-          WorkItem::kWow64Default,
+          KEY_WOW64_32KEY,
           google_update::kRegRenameCmdField);
     }
 
     post_install_task_list->AddWorkItem(regular_update_work_items.release());
   }
 
   AddRegisterComDllWorkItemsForPackage(installer_state, current_version,
                                        new_version, post_install_task_list);
 
   // If we're told that we're an MSI install, make sure to set the marker
@@ skipping 144 matching lines @@
 
 void AddSetMsiMarkerWorkItem(const InstallerState& installer_state,
                              BrowserDistribution* dist,
                              bool set,
                              WorkItemList* work_item_list) {
   DCHECK(work_item_list);
   DWORD msi_value = set ? 1 : 0;
   WorkItem* set_msi_work_item =
       work_item_list->AddSetRegValueWorkItem(installer_state.root_key(),
                                              dist->GetStateKey(),
-                                             WorkItem::kWow64Default,
+                                             KEY_WOW64_32KEY,
                                              google_update::kRegMSIField,
                                              msi_value,
                                              true);
   DCHECK(set_msi_work_item);
   set_msi_work_item->set_ignore_failure(true);
   set_msi_work_item->set_log_message("Could not write MSI marker!");
 }
 
 void AddDelegateExecuteWorkItems(const InstallerState& installer_state,
                                  const base::FilePath& target_path,
@@ skipping 188 matching lines @@
 void AddOsUpgradeWorkItems(const InstallerState& installer_state,
                            const base::FilePath& setup_path,
                            const Version& new_version,
                            const Product& product,
                            WorkItemList* install_list) {
   const HKEY root_key = installer_state.root_key();
   base::string16 cmd_key(
       GetRegCommandKey(product.distribution(), kCmdOnOsUpgrade));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
-    install_list->AddDeleteRegKeyWorkItem(
-                      root_key, cmd_key, WorkItem::kWow64Default)
+    install_list->AddDeleteRegKeyWorkItem(root_key, cmd_key, KEY_WOW64_32KEY)
         ->set_log_message("Removing OS upgrade command");
   } else {
     // Register with Google Update to have setup.exe --on-os-upgrade called on
     // OS upgrade.
     CommandLine cmd_line(installer_state
         .GetInstallerDirectory(new_version)
         .Append(setup_path.BaseName()));
     // Add the main option to indicate OS upgrade flow.
     cmd_line.AppendSwitch(installer::switches::kOnOsUpgrade);
     // Add product-specific options.
@@ skipping 11 matching lines @@
 
 void AddQueryEULAAcceptanceWorkItems(const InstallerState& installer_state,
                                      const base::FilePath& setup_path,
                                      const Version& new_version,
                                      const Product& product,
                                      WorkItemList* work_item_list) {
   const HKEY root_key = installer_state.root_key();
   base::string16 cmd_key(
       GetRegCommandKey(product.distribution(), kCmdQueryEULAAcceptance));
   if (installer_state.operation() == InstallerState::UNINSTALL) {
-    work_item_list->AddDeleteRegKeyWorkItem(
-        root_key, cmd_key, WorkItem::kWow64Default)
-            ->set_log_message("Removing query EULA acceptance command");
+    work_item_list->AddDeleteRegKeyWorkItem(root_key, cmd_key, KEY_WOW64_32KEY)
+        ->set_log_message("Removing query EULA acceptance command");
   } else {
     CommandLine cmd_line(installer_state
         .GetInstallerDirectory(new_version)
         .Append(setup_path.BaseName()));
     cmd_line.AppendSwitch(switches::kQueryEULAAcceptance);
     if (installer_state.system_install())
       cmd_line.AppendSwitch(installer::switches::kSystemLevel);
     if (installer_state.verbose_logging())
       cmd_line.AppendSwitch(installer::switches::kVerboseLogging);
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_is_web_accessible(true);
     cmd.set_is_run_as_user(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, work_item_list);
   }
 }
 
 void AddQuickEnableChromeFrameWorkItems(const InstallerState& installer_state,
                                         WorkItemList* work_item_list) {
   DCHECK(work_item_list);
 
   base::string16 cmd_key(
       GetRegCommandKey(BrowserDistribution::GetSpecificDistribution(
                            BrowserDistribution::CHROME_BINARIES),
                        kCmdQuickEnableCf));
 
   // Unconditionally remove the legacy Quick Enable command from the binaries.
   // Do this even if multi-install Chrome isn't installed to ensure that it is
   // not left behind in any case.
   work_item_list->AddDeleteRegKeyWorkItem(
-      installer_state.root_key(), cmd_key, WorkItem::kWow64Default)
-          ->set_log_message("removing " +
-              base::UTF16ToASCII(kCmdQuickEnableCf) + " command");
+                      installer_state.root_key(), cmd_key, KEY_WOW64_32KEY)
+      ->set_log_message("removing " + base::UTF16ToASCII(kCmdQuickEnableCf) +
+                        " command");
 }
 
 }  // namespace installer