Add WOW64 support to the installer registry work items

chrome/installer/setup/install_worker.cc

Index: chrome/installer/setup/install_worker.cc
diff --git a/chrome/installer/setup/install_worker.cc b/chrome/installer/setup/install_worker.cc
index 4831d3d1cb8496dacbe36b86e8f743a72b2af210..b9cc173c00ab9f8abaf4fb21ce87f45431c5246b 100644
--- a/chrome/installer/setup/install_worker.cc
+++ b/chrome/installer/setup/install_worker.cc
@@ -214,9 +214,11 @@ void AddCommandWithParameterWorkItems(const InstallerState& installer_state,
       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");
@@ -440,7 +442,7 @@ void AddDeleteUninstallShortcutsForMSIWorkItems(
   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.
@@ -609,22 +611,25 @@ void AddUninstallDelegateExecuteWorkItems(
     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
@@ -693,12 +698,21 @@ void AddUninstallShortcutWorkItems(const InstallerState& installer_state,
                                   &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,
+                                       installer::kUninstallStringField,
+                                       installer_path.value(),
+                                       true,
+                                       WorkItem::kWow64Default);
+  install_list->AddSetRegValueWorkItem(
+      reg_root,
+      update_state_key,
       installer::kUninstallArgumentsField,
-      uninstall_arguments.GetCommandLineString(), true);
+      uninstall_arguments.GetCommandLineString(),
+      true,
+      WorkItem::kWow64Default);
 
   // MSI installations will manage their own uninstall shortcuts.
   if (!installer_state.is_msi() && product.ShouldCreateUninstallEntry()) {
@@ -708,56 +722,93 @@ void AddUninstallShortcutWorkItems(const InstallerState& installer_state,
     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(),
-        true);
+    install_list->AddCreateRegKeyWorkItem(
+        reg_root, uninstall_reg, WorkItem::kWow64Default);
     install_list->AddSetRegValueWorkItem(reg_root,
-        uninstall_reg, installer::kUninstallStringField,
-        quoted_uninstall_cmd.GetCommandLineString(), true);
+                                         uninstall_reg,
+                                         installer::kUninstallDisplayNameField,
+                                         browser_dist->GetDisplayName(),
+                                         true,
+                                         WorkItem::kWow64Default);
+    install_list->AddSetRegValueWorkItem(
+        reg_root,
+        uninstall_reg,
+        installer::kUninstallStringField,
+        quoted_uninstall_cmd.GetCommandLineString(),
+        true,
+        WorkItem::kWow64Default);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
                                          L"InstallLocation",
                                          install_path.value(),
-                                         true);
+                                         true,
+                                         WorkItem::kWow64Default);
 
     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),
-                                         true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-                                         L"NoRepair", static_cast<DWORD>(1),
-                                         true);
-
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         L"DisplayIcon",
+                                         chrome_icon,
+                                         true,
+                                         WorkItem::kWow64Default);
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         L"NoModify",
+                                         static_cast<DWORD>(1),
+                                         true,
+                                         WorkItem::kWow64Default);
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
+                                         L"NoRepair",
+                                         static_cast<DWORD>(1),
+                                         true,
+                                         WorkItem::kWow64Default);
+
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
                                          L"Publisher",
                                          browser_dist->GetPublisherName(),
-                                         true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
+                                         true,
+                                         WorkItem::kWow64Default);
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
                                          L"Version",
                                          ASCIIToWide(new_version.GetString()),
-                                         true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
+                                         true,
+                                         WorkItem::kWow64Default);
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
                                          L"DisplayVersion",
                                          ASCIIToWide(new_version.GetString()),
-                                         true);
-    install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
+                                         true,
+                                         WorkItem::kWow64Default);
+    install_list->AddSetRegValueWorkItem(reg_root,
+                                         uninstall_reg,
                                          L"InstallDate",
                                          InstallUtil::GetCurrentDate(),
-                                         false);
+                                         false,
+                                         WorkItem::kWow64Default);
 
     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,
+          L"VersionMajor",
+          static_cast<DWORD>(version_components[2]),
+          true,
+          WorkItem::kWow64Default);
+      install_list->AddSetRegValueWorkItem(
+          reg_root,
+          uninstall_reg,
+          L"VersionMinor",
+          static_cast<DWORD>(version_components[3]),
+          true,
+          WorkItem::kWow64Default);
     }
   }
 }
@@ -772,15 +823,21 @@ void AddVersionKeyWorkItems(HKEY root,
   // 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,
+                               google_update::kRegNameField,
+                               product_name,
+                               true,  // overwrite name also
+                               WorkItem::kWow64Default);
+  list->AddSetRegValueWorkItem(root,
+                               version_key,
                                google_update::kRegOopcrashesField,
                                static_cast<DWORD>(1),
-                               false);  // set during first install
+                               false,  // set during first install
+                               WorkItem::kWow64Default);
   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
@@ -788,14 +845,19 @@ void AddVersionKeyWorkItems(HKEY root,
     base::string16 language(GetCurrentTranslation());
     if (LowerCaseEqualsASCII(language, "en-us"))
       language.resize(2);
-    list->AddSetRegValueWorkItem(root, version_key,
-                                 google_update::kRegLangField, language,
-                                 false);  // do not overwrite language
+    list->AddSetRegValueWorkItem(root,
+                                 version_key,
+                                 google_update::kRegLangField,
+                                 language,
+                                 false,  // do not overwrite language
+                                 WorkItem::kWow64Default);
   }
-  list->AddSetRegValueWorkItem(root, version_key,
+  list->AddSetRegValueWorkItem(root,
+                               version_key,
                                google_update::kRegVersionField,
                                ASCIIToWide(new_version.GetString()),
-                               true);  // overwrite version
+                               true,  // overwrite version
+                               WorkItem::kWow64Default);
 }
 
 // Mirror oeminstall the first time anything is installed multi.  There is no
@@ -834,15 +896,22 @@ void AddOemInstallWorkItems(const InstallationState& original_state,
       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,
                                            google_update::kRegOemInstallField,
-                                           oem_install, true);
+                                           oem_install,
+                                           true,
+                                           WorkItem::kWow64Default);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
-          root_key, multi_key, google_update::kRegOemInstallField);
+          root_key,
+          multi_key,
+          google_update::kRegOemInstallField,
+          WorkItem::kWow64Default);
     }
   }
 }
@@ -889,14 +958,21 @@ void AddEulaAcceptedWorkItems(const InstallationState& original_state,
       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,
+                                           google_update::kRegEULAAceptedField,
+                                           eula_accepted,
+                                           true,
+                                           WorkItem::kWow64Default);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
-          root_key, multi_key, google_update::kRegEULAAceptedField);
+          root_key,
+          multi_key,
+          google_update::kRegEULAAceptedField,
+          WorkItem::kWow64Default);
     }
   }
 }
@@ -922,8 +998,10 @@ void AddGoogleUpdateWorkItems(const InstallationState& original_state,
   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(),

[grt (UTC plus 2), 2014/05/21 16:41:05]

please move this up to the previous line. i think clang-format was too
aggressive here

[Will Harris, 2014/05/21 23:23:16]

Done.

+        WorkItem::kWow64Default);
   }
 
   // Creating the ClientState key for binaries, if we're migrating to multi then
@@ -935,14 +1013,16 @@ void AddGoogleUpdateWorkItems(const InstallationState& original_state,
 
     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,
                                            google_update::kRegBrandField,
                                            brand,
-                                           false);
+                                           false,
+                                           WorkItem::kWow64Default);
     }
   }
 
@@ -982,12 +1062,16 @@ void AddUsageStatsWorkItems(const InstallationState& original_state,
   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,
                                          google_update::kRegUsageStatsField,
-                                         usagestats, true);
+                                         usagestats,
+                                         true,
+                                         WorkItem::kWow64Default);
 
     for (Products::const_iterator scan = products.begin(), end = products.end();
          scan != end; ++scan) {
@@ -996,16 +1080,23 @@ void AddUsageStatsWorkItems(const InstallationState& original_state,
       BrowserDistribution* dist = (*scan)->distribution();
       if (installer_state.system_install()) {
         install_list->AddDeleteRegValueWorkItem(
-            root_key, dist->GetStateMediumKey(),
-            google_update::kRegUsageStatsField);
+            root_key,
+            dist->GetStateMediumKey(),
+            google_update::kRegUsageStatsField,
+            WorkItem::kWow64Default);
         // 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(),
-            google_update::kRegUsageStatsField);
+            HKEY_CURRENT_USER,
+            dist->GetStateKey(),
+            google_update::kRegUsageStatsField,
+            WorkItem::kWow64Default);
       }
       install_list->AddDeleteRegValueWorkItem(
-          root_key, dist->GetStateKey(), google_update::kRegUsageStatsField);
+          root_key,
+          dist->GetStateKey(),
+          google_update::kRegUsageStatsField,
+          WorkItem::kWow64Default);
     }
   }
 }
@@ -1055,17 +1146,28 @@ bool AppendPostInstallTasks(const InstallerState& installer_state,
       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,
             google_update::kRegOldVersionField,
-            ASCIIToWide(current_version->GetString()), true);
+            ASCIIToWide(current_version->GetString()),
+            true,
+            WorkItem::kWow64Default);
       }
       if (critical_version.IsValid()) {
-        in_use_update_work_items->AddSetRegValueWorkItem(root, version_key,
+        in_use_update_work_items->AddSetRegValueWorkItem(
+            root,
+            version_key,
             google_update::kRegCriticalVersionField,
-            ASCIIToWide(critical_version.GetString()), true);
+            ASCIIToWide(critical_version.GetString()),
+            true,
+            WorkItem::kWow64Default);
       } else {
-        in_use_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
-            google_update::kRegCriticalVersionField);
+        in_use_update_work_items->AddDeleteRegValueWorkItem(
+            root,
+            version_key,
+            google_update::kRegCriticalVersionField,
+            WorkItem::kWow64Default);
       }
 
       // Adding this registry entry for all products (but the binaries) is
@@ -1077,8 +1179,12 @@ bool AppendPostInstallTasks(const InstallerState& installer_state,
         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,
+            google_update::kRegRenameCmdField,
+            product_rename_cmd.GetCommandLineString(),
+            true,
+            WorkItem::kWow64Default);
       }
     }
 
@@ -1096,12 +1202,21 @@ bool AppendPostInstallTasks(const InstallerState& installer_state,
     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,
-          google_update::kRegOldVersionField);
-      regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
-          google_update::kRegCriticalVersionField);
-      regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
-          google_update::kRegRenameCmdField);
+      regular_update_work_items->AddDeleteRegValueWorkItem(
+          root,
+          version_key,
+          google_update::kRegOldVersionField,
+          WorkItem::kWow64Default);
+      regular_update_work_items->AddDeleteRegValueWorkItem(
+          root,
+          version_key,
+          google_update::kRegCriticalVersionField,
+          WorkItem::kWow64Default);
+      regular_update_work_items->AddDeleteRegValueWorkItem(
+          root,
+          version_key,
+          google_update::kRegRenameCmdField,
+          WorkItem::kWow64Default);
     }
 
     post_install_task_list->AddWorkItem(regular_update_work_items.release());
@@ -1262,9 +1377,13 @@ void AddSetMsiMarkerWorkItem(const InstallerState& installer_state,
                              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(),
+                                             google_update::kRegMSIField,
+                                             msi_value,
+                                             true,
+                                             WorkItem::kWow64Default);
   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!");
@@ -1317,18 +1436,28 @@ void AddDelegateExecuteWorkItems(const InstallerState& installer_state,
     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,
+                                 L"",
+                                 L"CommandExecuteImpl Class",
+                                 true,
+                                 WorkItem::kWow64Default);
     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, L"", command, true, WorkItem::kWow64Default);
+    list->AddSetRegValueWorkItem(root,
+                                 subkey,
+                                 L"ServerExecutable",
+                                 delegate_execute.value(),
+                                 true,
+                                 WorkItem::kWow64Default);
 
     subkey.assign(delegate_execute_path).append(L"\\Programmable");
-    list->AddCreateRegKeyWorkItem(root, subkey);
+    list->AddCreateRegKeyWorkItem(root, subkey, WorkItem::kWow64Default);
   }
 }
 
@@ -1353,9 +1482,14 @@ void AddActiveSetupWorkItems(const InstallerState& installer_state,
   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,
+                               L"",
+                               dist->GetDisplayName(),
+                               true,
+                               WorkItem::kWow64Default);
 
   base::FilePath active_setup_exe(installer_state.GetInstallerDirectory(
       new_version).Append(kActiveSetupExe));
@@ -1364,19 +1498,35 @@ void AddActiveSetupWorkItems(const InstallerState& installer_state,
   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,
+                               L"StubPath",
+                               cmd.GetCommandLineString(),
+                               true,
+                               WorkItem::kWow64Default);
 
   // 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, L"IsInstalled",
-                               static_cast<DWORD>(1U), true);
-
-  list->AddSetRegValueWorkItem(root, active_setup_path, L"Version",
-                               kActiveSetupVersion, true);
+  list->AddSetRegValueWorkItem(root,
+                               active_setup_path,
+                               L"Localized Name",
+                               dist->GetDisplayName(),
+                               true,
+                               WorkItem::kWow64Default);
+
+  list->AddSetRegValueWorkItem(root,
+                               active_setup_path,
+                               L"IsInstalled",
+                               static_cast<DWORD>(1U),
+                               true,
+                               WorkItem::kWow64Default);
+
+  list->AddSetRegValueWorkItem(root,
+                               active_setup_path,
+                               L"Version",
+                               kActiveSetupVersion,
+                               true,
+                               WorkItem::kWow64Default);
 }
 
 void AddDeleteOldIELowRightsPolicyWorkItems(
@@ -1386,7 +1536,8 @@ void AddDeleteOldIELowRightsPolicyWorkItems(
 
   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,
@@ -1438,8 +1589,9 @@ void AddOsUpgradeWorkItems(const InstallerState& installer_state,
       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.
@@ -1470,8 +1622,9 @@ void AddQueryEULAAcceptanceWorkItems(const InstallerState& installer_state,
   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)
@@ -1501,9 +1654,9 @@ void AddQuickEnableChromeFrameWorkItems(const InstallerState& installer_state,
   // 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