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);

[grt (UTC plus 2), 2014/05/27 16:42:08]

as with my comment on line 734, i think this should delete from both the default
and the opposite bitness to cover the case of migrating from non-msi to msi and
from 32->64 or 64->32 at the same time.

   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;
+  // Delete both 64 and 32 keys to clean up from previous installs which placed
+  // the delegate registration key in the wrong hive.

[grt (UTC plus 2), 2014/05/27 16:42:08]

"in the wrong hive" makes it sound like previous installs did the wrong thing.
this double-delete needs to be here for the legitimate case of a 32->64 or
64->32 migration no matter what, no? if this is correct, please change the
comment so that it's clear that both are deleted to handle the case of migrating
from one bitness to the other on upgrade. i don't think there's a need to
reference the bug, since the comment alone justifies the double-delete.

[Will Harris, 2014/05/27 19:25:10]

Done.

+  // See http://crbug.com/348626.
   list->AddDeleteRegKeyWorkItem(root,
                                 delegate_execute_path,
-                                WorkItem::kWow64Default);
+                                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);

[grt (UTC plus 2), 2014/05/27 16:42:08]

this and line 640 should both be KEY_WOW64_32KEY since the old registrations
only existed for 32-bit Chrome.

[Will Harris, 2014/05/27 19:25:10]

Done.

   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);
 }
 
@@ skipping 57 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);

[grt (UTC plus 2), 2014/05/27 16:42:08]

why force the add/remove control panel data into the 32-bit section? in
contrast, isn't the right thing to do to delete the data in the opposite-bitness
section (to handle 32->64 or 64->32 migration) and write into the default for
the current bitness?

[Will Harris, 2014/05/27 19:25:10]

as discussed, while we're leaving Chrome in C:\Program Files (x86) even on
64-bit platforms, I'm leaving the uninstall registry entry here too.  I'll move
this when I move the files.

[grt (UTC plus 2), 2014/05/27 22:06:19]

SGTM

     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);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          L"InstallDate",
                                          InstallUtil::GetCurrentDate(),
                                          false);

[grt (UTC plus 2), 2014/05/27 16:42:08]

it'd be nice to preserve the InstallDate when migrating from 32->64 or back

[Will Harris, 2014/05/27 19:25:10]

pretty sure this code does preserve, since it's only written into the 32-bit
hive, and the 'false' on the work item means it won't be overwritten if already
existing.

[grt (UTC plus 2), 2014/05/27 22:06:19]

i was referring to the (future) case where the uninstall info is moved from the
32-bit to 64-bit area of the registry. in this case, we'll need to copy this
value over.

[Will Harris, 2014/05/27 22:29:28]

Put a TODO so I don't forget to do this.

 
     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);
+        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 23 matching lines @@
             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);
+        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 189 matching lines @@
                            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)
+                      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 12 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)
+        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);
@@ skipping 10 matching lines @@
 
   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)
+      installer_state.root_key(), cmd_key, KEY_WOW64_32KEY)
           ->set_log_message("removing " +
               base::UTF16ToASCII(kCmdQuickEnableCf) + " command");
 }
 
 }  // namespace installer