Add WOW64 support to the installer registry work items

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 196 matching lines @@
                                       WorkItemList* work_item_list) {
   DCHECK(command_key);
   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)->set_log_message(
-            "removing " + base::UTF16ToASCII(command_key) + " command");
+    work_item_list->AddDeleteRegKeyWorkItem(installer_state.root_key(),
+                                            full_cmd_key,
+                                            WorkItem::kWow64Default)
+        ->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);
     cmd.AddWorkItems(installer_state.root_key(), full_cmd_key, work_item_list);
   }
@@ skipping 203 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);
+      reg_root, uninstall_reg, WorkItem::kWow64Default);
   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);
+  list->AddDeleteRegKeyWorkItem(root,
+                                delegate_execute_path,
+                                WorkItem::kWow64Default);
 
   // 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}");
+                                L"{0BA0D4E9-2259-4963-B9AE-A839F7CB7544}",
+                                WorkItem::kWow64Default);
   list->AddDeleteRegKeyWorkItem(root,
                                 L"Software\\Classes\\TypeLib\\"
 #if defined(GOOGLE_CHROME_BUILD)
-                                L"{4E805ED8-EBA0-4601-9681-12815A56EBFD}"
+                                L"{4E805ED8-EBA0-4601-9681-12815A56EBFD}",
 #else
-                                L"{7779FB70-B399-454A-AA1A-BAA850032B10}"
+                                L"{7779FB70-B399-454A-AA1A-BAA850032B10}",
 #endif
-                                );
+                                WorkItem::kWow64Default);
 }
 
 // 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 48 matching lines @@
   base::FilePath install_path(installer_state.target_path());
   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);
-  install_list->AddSetRegValueWorkItem(reg_root, update_state_key,
-      installer::kUninstallStringField, installer_path.value(), true);
-  install_list->AddSetRegValueWorkItem(reg_root, update_state_key,
+  install_list->AddCreateRegKeyWorkItem(
+      reg_root, update_state_key, WorkItem::kWow64Default);
+  install_list->AddSetRegValueWorkItem(reg_root,
+                                       update_state_key,
+                                       WorkItem::kWow64Default,
+                                       installer::kUninstallStringField,
+                                       installer_path.value(),
+                                       true);
+  install_list->AddSetRegValueWorkItem(
+      reg_root,
+      update_state_key,
+      WorkItem::kWow64Default,
       installer::kUninstallArgumentsField,
-      uninstall_arguments.GetCommandLineString(), true);
+      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);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-        installer::kUninstallDisplayNameField, browser_dist->GetDisplayName(),
+    install_list->AddCreateRegKeyWorkItem(
+        reg_root, uninstall_reg, WorkItem::kWow64Default);
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         WorkItem::kWow64Default,
+                                         installer::kUninstallDisplayNameField,
+                                         browser_dist->GetDisplayName(),
+                                         true);
+    install_list->AddSetRegValueWorkItem(
+        reg_root,
+        uninstall_reg,
+        WorkItem::kWow64Default,
+        installer::kUninstallStringField,
+        quoted_uninstall_cmd.GetCommandLineString(),
         true);
     install_list->AddSetRegValueWorkItem(reg_root,
-        uninstall_reg, installer::kUninstallStringField,
-        quoted_uninstall_cmd.GetCommandLineString(), true);
-    install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
+                                         WorkItem::kWow64Default,
                                          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,
-                                         L"DisplayIcon", chrome_icon, true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-                                         L"NoModify", static_cast<DWORD>(1),
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         WorkItem::kWow64Default,
+                                         L"DisplayIcon",
+                                         chrome_icon,
                                          true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-                                         L"NoRepair", static_cast<DWORD>(1),
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         WorkItem::kWow64Default,
+                                         L"NoModify",
+                                         static_cast<DWORD>(1),
+                                         true);
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         WorkItem::kWow64Default,
+                                         L"NoRepair",
+                                         static_cast<DWORD>(1),
                                          true);
 
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         WorkItem::kWow64Default,
                                          L"Publisher",
                                          browser_dist->GetPublisherName(),
                                          true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         WorkItem::kWow64Default,
                                          L"Version",
                                          ASCIIToWide(new_version.GetString()),
                                          true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         WorkItem::kWow64Default,
                                          L"DisplayVersion",
                                          ASCIIToWide(new_version.GetString()),
                                          true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         WorkItem::kWow64Default,
                                          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,
-          L"VersionMajor", static_cast<DWORD>(version_components[2]), true);
-      install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-          L"VersionMinor", static_cast<DWORD>(version_components[3]), true);
+      install_list->AddSetRegValueWorkItem(
+          reg_root,
+          uninstall_reg,
+          WorkItem::kWow64Default,
+          L"VersionMajor",
+          static_cast<DWORD>(version_components[2]),
+          true);
+      install_list->AddSetRegValueWorkItem(
+          reg_root,
+          uninstall_reg,
+          WorkItem::kWow64Default,
+          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);
+  list->AddCreateRegKeyWorkItem(root, version_key, WorkItem::kWow64Default);
 
   base::string16 product_name(dist->GetDisplayName());
-  list->AddSetRegValueWorkItem(root, version_key, google_update::kRegNameField,
-                               product_name, true);  // overwrite name also
-  list->AddSetRegValueWorkItem(root, version_key,
+  list->AddSetRegValueWorkItem(root,
+                               version_key,
+                               WorkItem::kWow64Default,
+                               google_update::kRegNameField,
+                               product_name,
+                               true);  // overwrite name also
+  list->AddSetRegValueWorkItem(root,
+                               version_key,
+                               WorkItem::kWow64Default,
                                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,
-                                 google_update::kRegLangField, language,
+    list->AddSetRegValueWorkItem(root,
+                                 version_key,
+                                 WorkItem::kWow64Default,
+                                 google_update::kRegLangField,
+                                 language,
                                  false);  // do not overwrite language
   }
-  list->AddSetRegValueWorkItem(root, version_key,
+  list->AddSetRegValueWorkItem(root,
+                               version_key,
+                               WorkItem::kWow64Default,
                                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 21 matching lines @@
       return;
     }
     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);
+      install_list->AddCreateRegKeyWorkItem(
+          root_key, multi_key, WorkItem::kWow64Default);
       // Always overwrite an old value.
-      install_list->AddSetRegValueWorkItem(root_key, multi_key,
+      install_list->AddSetRegValueWorkItem(root_key,
+                                           multi_key,
+                                           WorkItem::kWow64Default,
                                            google_update::kRegOemInstallField,
-                                           oem_install, true);
+                                           oem_install,
+                                           true);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
-          root_key, multi_key, google_update::kRegOemInstallField);
+          root_key,
+          multi_key,
+          WorkItem::kWow64Default,
+          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,
                               const InstallerState& installer_state,
@@ skipping 26 matching lines @@
         have_eula_accepted = true;
         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);
-      install_list->AddSetRegValueWorkItem(
-          root_key, multi_key, google_update::kRegEULAAceptedField,
-          eula_accepted, true);
+      install_list->AddCreateRegKeyWorkItem(
+          root_key, multi_key, WorkItem::kWow64Default);
+      install_list->AddSetRegValueWorkItem(root_key,
+                                           multi_key,
+                                           WorkItem::kWow64Default,
+                                           google_update::kRegEULAAceptedField,
+                                           eula_accepted,
+                                           true);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
-          root_key, multi_key, google_update::kRegEULAAceptedField);
+          root_key,
+          multi_key,
+          WorkItem::kWow64Default,
+          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());
+        installer_state.multi_package_binaries_distribution()
+            ->GetStateMediumKey().c_str(),
+        WorkItem::kWow64Default);
   }
 
   // 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);
+      install_list->AddCreateRegKeyWorkItem(
+          root_key, multi_key, WorkItem::kWow64Default);
       // 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,
                                            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);
+    install_list->AddCreateRegKeyWorkItem(
+        root_key, state_key, WorkItem::kWow64Default);
     // 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,
+    install_list->AddSetRegValueWorkItem(root_key,
+                                         state_key,
+                                         WorkItem::kWow64Default,
                                          google_update::kRegUsageStatsField,
-                                         usagestats, true);
+                                         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(),
+            root_key,
+            dist->GetStateMediumKey(),
+            WorkItem::kWow64Default,
             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(),
+            HKEY_CURRENT_USER,
+            dist->GetStateKey(),
+            WorkItem::kWow64Default,
             google_update::kRegUsageStatsField);
       }
       install_list->AddDeleteRegValueWorkItem(
-          root_key, dist->GetStateKey(), google_update::kRegUsageStatsField);
+          root_key,
+          dist->GetStateKey(),
+          WorkItem::kWow64Default,
+          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,
                             WorkItemList* post_install_task_list) {
@@ skipping 29 matching lines @@
 
     if (installer_state.verbose_logging())
       rename.AppendSwitch(switches::kVerboseLogging);
 
     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,
+        in_use_update_work_items->AddSetRegValueWorkItem(
+            root,
+            version_key,
+            WorkItem::kWow64Default,
             google_update::kRegOldVersionField,
-            ASCIIToWide(current_version->GetString()), true);
+            ASCIIToWide(current_version->GetString()),
+            true);
       }
       if (critical_version.IsValid()) {
-        in_use_update_work_items->AddSetRegValueWorkItem(root, version_key,
+        in_use_update_work_items->AddSetRegValueWorkItem(
+            root,
+            version_key,
+            WorkItem::kWow64Default,
             google_update::kRegCriticalVersionField,
-            ASCIIToWide(critical_version.GetString()), true);
+            ASCIIToWide(critical_version.GetString()),
+            true);
       } else {
-        in_use_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
+        in_use_update_work_items->AddDeleteRegValueWorkItem(
+            root,
+            version_key,
+            WorkItem::kWow64Default,
             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, google_update::kRegRenameCmdField,
-            product_rename_cmd.GetCommandLineString(), true);
+            root,
+            version_key,
+            WorkItem::kWow64Default,
+            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,
+      regular_update_work_items->AddDeleteRegValueWorkItem(
+          root,
+          version_key,
+          WorkItem::kWow64Default,
           google_update::kRegOldVersionField);
-      regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
+      regular_update_work_items->AddDeleteRegValueWorkItem(
+          root,
+          version_key,
+          WorkItem::kWow64Default,
           google_update::kRegCriticalVersionField);
-      regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
+      regular_update_work_items->AddDeleteRegValueWorkItem(
+          root,
+          version_key,
+          WorkItem::kWow64Default,
           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 141 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(),
-      google_update::kRegMSIField, msi_value, true);
+  WorkItem* set_msi_work_item =
+      work_item_list->AddSetRegValueWorkItem(installer_state.root_key(),
+                                             dist->GetStateKey(),
+                                             WorkItem::kWow64Default,
+                                             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,
                                  const Version& new_version,
                                  const Product& product,
                                  WorkItemList* list) {
@@ skipping 32 matching lines @@
     base::FilePath delegate_execute(target_path);
     if (new_version.IsValid())
       delegate_execute = delegate_execute.AppendASCII(new_version.GetString());
     delegate_execute = delegate_execute.Append(kDelegateExecuteExe);
 
     // Command-line featuring the quoted path to the exe.
     base::string16 command(1, L'"');
     command.append(delegate_execute.value()).append(1, L'"');
 
     // Register the CommandExecuteImpl class in Software\Classes\CLSID\...
-    list->AddCreateRegKeyWorkItem(root, delegate_execute_path);
-    list->AddSetRegValueWorkItem(root, delegate_execute_path, L"",
-                                 L"CommandExecuteImpl Class", true);
+    list->AddCreateRegKeyWorkItem(
+        root, delegate_execute_path, WorkItem::kWow64Default);
+    list->AddSetRegValueWorkItem(root,
+                                 delegate_execute_path,
+                                 WorkItem::kWow64Default,
+                                 L"",
+                                 L"CommandExecuteImpl Class",
+                                 true);
     base::string16 subkey(delegate_execute_path);
     subkey.append(L"\\LocalServer32");
-    list->AddCreateRegKeyWorkItem(root, subkey);
-    list->AddSetRegValueWorkItem(root, subkey, L"", command, true);
-    list->AddSetRegValueWorkItem(root, subkey, L"ServerExecutable",
-                                 delegate_execute.value(), true);
+    list->AddCreateRegKeyWorkItem(root, subkey, WorkItem::kWow64Default);
+    list->AddSetRegValueWorkItem(
+        root, subkey, WorkItem::kWow64Default, L"", command, true);
+    list->AddSetRegValueWorkItem(root,
+                                 subkey,
+                                 WorkItem::kWow64Default,
+                                 L"ServerExecutable",
+                                 delegate_execute.value(),
+                                 true);
 
     subkey.assign(delegate_execute_path).append(L"\\Programmable");
-    list->AddCreateRegKeyWorkItem(root, subkey);
+    list->AddCreateRegKeyWorkItem(root, subkey, WorkItem::kWow64Default);
   }
 }
 
 void AddActiveSetupWorkItems(const InstallerState& installer_state,
                              const base::FilePath& setup_path,
                              const Version& new_version,
                              const Product& product,
                              WorkItemList* list) {
   DCHECK(installer_state.operation() != InstallerState::UNINSTALL);
   BrowserDistribution* dist = product.distribution();
 
   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 " << dist->GetDisplayName();
     return;
   }
   DCHECK(installer_state.RequiresActiveSetup());
 
   const HKEY root = HKEY_LOCAL_MACHINE;
   const base::string16 active_setup_path(InstallUtil::GetActiveSetupPath(dist));
 
   VLOG(1) << "Adding registration items for Active Setup.";
-  list->AddCreateRegKeyWorkItem(root, active_setup_path);
-  list->AddSetRegValueWorkItem(root, active_setup_path, L"",
-                               dist->GetDisplayName(), true);
+  list->AddCreateRegKeyWorkItem(
+      root, active_setup_path, WorkItem::kWow64Default);
+  list->AddSetRegValueWorkItem(root,
+                               active_setup_path,
+                               WorkItem::kWow64Default,
+                               L"",
+                               dist->GetDisplayName(),
+                               true);
 
   base::FilePath active_setup_exe(installer_state.GetInstallerDirectory(
       new_version).Append(kActiveSetupExe));
   CommandLine cmd(active_setup_exe);
   cmd.AppendSwitch(installer::switches::kConfigureUserSettings);
   cmd.AppendSwitch(installer::switches::kVerboseLogging);
   cmd.AppendSwitch(installer::switches::kSystemLevel);
   product.AppendProductFlags(&cmd);
-  list->AddSetRegValueWorkItem(root, active_setup_path, L"StubPath",
-                               cmd.GetCommandLineString(), true);
+  list->AddSetRegValueWorkItem(root,
+                               active_setup_path,
+                               WorkItem::kWow64Default,
+                               L"StubPath",
+                               cmd.GetCommandLineString(),
+                               true);
 
   // TODO(grt): http://crbug.com/75152 Write a reference to a localized
   // resource.
-  list->AddSetRegValueWorkItem(root, active_setup_path, L"Localized Name",
-                               dist->GetDisplayName(), true);
+  list->AddSetRegValueWorkItem(root,
+                               active_setup_path,
+                               WorkItem::kWow64Default,
+                               L"Localized Name",
+                               dist->GetDisplayName(),
+                               true);
 
-  list->AddSetRegValueWorkItem(root, active_setup_path, L"IsInstalled",
-                               static_cast<DWORD>(1U), true);
+  list->AddSetRegValueWorkItem(root,
+                               active_setup_path,
+                               WorkItem::kWow64Default,
+                               L"IsInstalled",
+                               static_cast<DWORD>(1U),
+                               true);
 
-  list->AddSetRegValueWorkItem(root, active_setup_path, L"Version",
-                               kActiveSetupVersion, true);
+  list->AddSetRegValueWorkItem(root,
+                               active_setup_path,
+                               WorkItem::kWow64Default,
+                               L"Version",
+                               kActiveSetupVersion,
+                               true);
 }
 
 void AddDeleteOldIELowRightsPolicyWorkItems(
     const InstallerState& installer_state,
     WorkItemList* install_list) {
   DCHECK(install_list);
 
   base::string16 key_path;
   GetOldIELowRightsElevationPolicyKeyPath(&key_path);
-  install_list->AddDeleteRegKeyWorkItem(installer_state.root_key(), key_path);
+  install_list->AddDeleteRegKeyWorkItem(
+      installer_state.root_key(), key_path, WorkItem::kWow64Default);
 }
 
 void AppendUninstallCommandLineFlags(const InstallerState& installer_state,
                                      const Product& product,
                                      CommandLine* uninstall_cmd) {
   DCHECK(uninstall_cmd);
 
   uninstall_cmd->AppendSwitch(installer::switches::kUninstall);
 
   // Append the product-specific uninstall flags.
@@ skipping 31 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)->
-        set_log_message("Removing OS upgrade command");
+    install_list->AddDeleteRegKeyWorkItem(
+                      root_key, cmd_key, WorkItem::kWow64Default)
+        ->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.
     product.AppendProductFlags(&cmd_line);
@@ skipping 10 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)->
-        set_log_message("Removing query EULA acceptance command");
+    work_item_list->AddDeleteRegKeyWorkItem(
+        root_key, cmd_key, WorkItem::kWow64Default)
+            ->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)->set_log_message(
-          "removing " + base::UTF16ToASCII(kCmdQuickEnableCf) + " command");
-
+      installer_state.root_key(), cmd_key, WorkItem::kWow64Default)
+          ->set_log_message("removing " +
+              base::UTF16ToASCII(kCmdQuickEnableCf) + " command");
 }
 
 }  // namespace installer