Add WOW64 support to the installer registry work items

chrome/installer/util/work_item_list.cc

 // Copyright (c) 2011 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.
 
 #include "chrome/installer/util/work_item_list.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "chrome/installer/util/callback_work_item.h"
-#include "chrome/installer/util/copy_reg_key_work_item.h"
 #include "chrome/installer/util/copy_tree_work_item.h"
 #include "chrome/installer/util/create_dir_work_item.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/delete_reg_key_work_item.h"
 #include "chrome/installer/util/delete_reg_value_work_item.h"
 #include "chrome/installer/util/delete_tree_work_item.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/installer/util/move_tree_work_item.h"
 #include "chrome/installer/util/self_reg_work_item.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
@@ skipping 53 matching lines @@
   list_.push_back(work_item);
 }
 
 WorkItem* WorkItemList::AddCallbackWorkItem(
     base::Callback<bool(const CallbackWorkItem&)> callback) {
   WorkItem* item = WorkItem::CreateCallbackWorkItem(callback);
   AddWorkItem(item);
   return item;
 }
 
-WorkItem* WorkItemList::AddCopyRegKeyWorkItem(
-    HKEY predefined_root,
-    const std::wstring& source_key_path,
-    const std::wstring& dest_key_path,
-    CopyOverWriteOption overwrite_option) {
-  WorkItem* item = WorkItem::CreateCopyRegKeyWorkItem(
-      predefined_root, source_key_path, dest_key_path, overwrite_option);
-  AddWorkItem(item);
-  return item;
-}
-
 WorkItem* WorkItemList::AddCopyTreeWorkItem(
     const std::wstring& source_path,
     const std::wstring& dest_path,
     const std::wstring& temp_dir,
     CopyOverWriteOption overwrite_option,
     const std::wstring& alternative_path) {
   WorkItem* item = WorkItem::CreateCopyTreeWorkItem(
       base::FilePath(source_path),
       base::FilePath(dest_path),
       base::FilePath(temp_dir),
       overwrite_option,
       base::FilePath(alternative_path));
   AddWorkItem(item);
   return item;
 }
 
 WorkItem* WorkItemList::AddCreateDirWorkItem(const base::FilePath& path) {
   WorkItem* item = WorkItem::CreateCreateDirWorkItem(path);
   AddWorkItem(item);
   return item;
 }
 
 WorkItem* WorkItemList::AddCreateRegKeyWorkItem(HKEY predefined_root,
-                                                const std::wstring& path) {
-  WorkItem* item = WorkItem::CreateCreateRegKeyWorkItem(predefined_root, path);
+                                                const std::wstring& path,
+                                                REGSAM wow64_access) {
+  WorkItem* item =
+      WorkItem::CreateCreateRegKeyWorkItem(predefined_root, path, wow64_access);
   AddWorkItem(item);
   return item;
 }
 
 WorkItem* WorkItemList::AddDeleteRegKeyWorkItem(HKEY predefined_root,
-                                                const std::wstring& path) {
-  WorkItem* item = WorkItem::CreateDeleteRegKeyWorkItem(predefined_root, path);
+                                                const std::wstring& path,
+                                                REGSAM wow64_access) {
+  WorkItem* item =
+      WorkItem::CreateDeleteRegKeyWorkItem(predefined_root, path, wow64_access);
   AddWorkItem(item);
   return item;
 }
 
 WorkItem* WorkItemList::AddDeleteRegValueWorkItem(
     HKEY predefined_root,
     const std::wstring& key_path,
+    REGSAM wow64_access,
     const std::wstring& value_name) {
-  WorkItem* item = WorkItem::CreateDeleteRegValueWorkItem(predefined_root,
-                                                          key_path, value_name);
+  WorkItem* item = WorkItem::CreateDeleteRegValueWorkItem(
+      predefined_root, key_path, wow64_access, value_name);
   AddWorkItem(item);
   return item;
 }
 
 WorkItem* WorkItemList::AddDeleteTreeWorkItem(
     const base::FilePath& root_path,
     const base::FilePath& temp_path,
     const std::vector<base::FilePath>& key_paths) {
   WorkItem* item = WorkItem::CreateDeleteTreeWorkItem(root_path, temp_path,
                                                       key_paths);
@@ skipping 12 matching lines @@
                                             const std::wstring& temp_dir,
                                             MoveTreeOption duplicate_option) {
   WorkItem* item = WorkItem::CreateMoveTreeWorkItem(base::FilePath(source_path),
                                                     base::FilePath(dest_path),
                                                     base::FilePath(temp_dir),
                                                     duplicate_option);
   AddWorkItem(item);
   return item;
 }
 
-WorkItem* WorkItemList::AddSetRegValueWorkItem(
-    HKEY predefined_root,
-    const std::wstring& key_path,
-    const std::wstring& value_name,
-    const std::wstring& value_data,
-    bool overwrite) {
+WorkItem* WorkItemList::AddSetRegValueWorkItem(HKEY predefined_root,
+                                               const std::wstring& key_path,
+                                               REGSAM wow64_access,
+                                               const std::wstring& value_name,
+                                               const std::wstring& value_data,
+                                               bool overwrite) {
   WorkItem* item = WorkItem::CreateSetRegValueWorkItem(predefined_root,
                                                        key_path,
+                                                       wow64_access,
                                                        value_name,
                                                        value_data,
                                                        overwrite);
   AddWorkItem(item);
   return item;
 }
 
 WorkItem* WorkItemList::AddSetRegValueWorkItem(HKEY predefined_root,
                                                const std::wstring& key_path,
+                                               REGSAM wow64_access,
                                                const std::wstring& value_name,
                                                DWORD value_data,
                                                bool overwrite) {
   WorkItem* item = WorkItem::CreateSetRegValueWorkItem(predefined_root,
                                                        key_path,
+                                                       wow64_access,
                                                        value_name,
                                                        value_data,
                                                        overwrite);
   AddWorkItem(item);
   return item;
 }
 
 WorkItem* WorkItemList::AddSetRegValueWorkItem(HKEY predefined_root,
                                                const std::wstring& key_path,
+                                               REGSAM wow64_access,
                                                const std::wstring& value_name,
                                                int64 value_data,
                                                bool overwrite) {
   WorkItem* item = reinterpret_cast<WorkItem*>(
-      WorkItem::CreateSetRegValueWorkItem(predefined_root, key_path, value_name,
-                                          value_data, overwrite));
+      WorkItem::CreateSetRegValueWorkItem(predefined_root,
+                                          key_path,
+                                          wow64_access,
+                                          value_name,
+                                          value_data,
+                                          overwrite));
   AddWorkItem(item);
   return item;
 }
 
 WorkItem* WorkItemList::AddSelfRegWorkItem(const std::wstring& dll_path,
                                            bool do_register,
                                            bool user_level_registration) {
   WorkItem* item = WorkItem::CreateSelfRegWorkItem(dll_path, do_register,
                                                    user_level_registration);
   AddWorkItem(item);
@@ skipping 24 matching lines @@
   if (result)
     VLOG(1) << "NoRollbackWorkItemList: list execution succeeded";
 
   status_ = LIST_EXECUTED;
   return result;
 }
 
 void NoRollbackWorkItemList::Rollback() {
   // Ignore rollback.
 }