Add WOW64 support to the installer registry work items

chrome/installer/util/work_item_list_unittest.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.
 
 #include <windows.h>
 
 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 51 matching lines @@
   ASSERT_FALSE(base::PathExists(dir_to_create));
 
   work_item.reset(reinterpret_cast<WorkItem*>(
       WorkItem::CreateCreateDirWorkItem(dir_to_create)));
   work_item_list->AddWorkItem(work_item.release());
 
   std::wstring key_to_create(kTestRoot);
   key_to_create.push_back(base::FilePath::kSeparators[0]);
   key_to_create.append(L"ExecutionSuccess");
 
-  work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, key_to_create)));
+  work_item.reset(
+      reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem(
+          HKEY_CURRENT_USER, key_to_create, WorkItem::kWow64Default)));
   work_item_list->AddWorkItem(work_item.release());
 
   std::wstring name(kName);
   std::wstring data(kDataStr);
   work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, key_to_create,
-                                          name, data, false)));
+      WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER,
+                                          key_to_create,
+                                          WorkItem::kWow64Default,
+                                          name,
+                                          data,
+                                          false)));
   work_item_list->AddWorkItem(work_item.release());
 
   EXPECT_TRUE(work_item_list->Do());
 
   // Verify all WorkItems have been executed.
   RegKey key;
   EXPECT_EQ(ERROR_SUCCESS,
       key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ));
   std::wstring read_out;
   EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out));
@@ skipping 23 matching lines @@
   ASSERT_FALSE(base::PathExists(dir_to_create));
 
   work_item.reset(reinterpret_cast<WorkItem*>(
       WorkItem::CreateCreateDirWorkItem(dir_to_create)));
   work_item_list->AddWorkItem(work_item.release());
 
   std::wstring key_to_create(kTestRoot);
   key_to_create.push_back(base::FilePath::kSeparators[0]);
   key_to_create.append(L"ExecutionFail");
 
-  work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, key_to_create)));
+  work_item.reset(
+      reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem(
+          HKEY_CURRENT_USER, key_to_create, WorkItem::kWow64Default)));
   work_item_list->AddWorkItem(work_item.release());
 
   std::wstring not_created_key(kTestRoot);
   not_created_key.push_back(base::FilePath::kSeparators[0]);
   not_created_key.append(L"NotCreated");
   std::wstring name(kName);
   std::wstring data(kDataStr);
   work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, not_created_key,
-                                          name, data, false)));
+      WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER,
+                                          not_created_key,
+                                          WorkItem::kWow64Default,
+                                          name,
+                                          data,
+                                          false)));
   work_item_list->AddWorkItem(work_item.release());
 
   // This one will not be executed because we will fail early.
-  work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER,
-                                           not_created_key)));
+  work_item.reset(
+      reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem(
+          HKEY_CURRENT_USER, not_created_key, WorkItem::kWow64Default)));
   work_item_list->AddWorkItem(work_item.release());
 
   EXPECT_FALSE(work_item_list->Do());
 
   // Verify the first 2 WorkItems have been executed.
   RegKey key;
   EXPECT_EQ(ERROR_SUCCESS,
       key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ));
   key.Close();
   EXPECT_TRUE(base::PathExists(dir_to_create));
@@ skipping 23 matching lines @@
       WorkItem::CreateCreateDirWorkItem(dir_to_create)));
   work_item_list->AddWorkItem(work_item.release());
 
   scoped_ptr<WorkItemList> conditional_work_item_list(
       WorkItem::CreateConditionalWorkItemList(
           new ConditionRunIfFileExists(dir_to_create)));
 
   std::wstring key_to_create(kTestRoot);
   key_to_create.push_back(base::FilePath::kSeparators[0]);
   key_to_create.append(L"ExecutionSuccess");
-  work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, key_to_create)));
+  work_item.reset(
+      reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem(
+          HKEY_CURRENT_USER, key_to_create, WorkItem::kWow64Default)));
   conditional_work_item_list->AddWorkItem(work_item.release());
 
   std::wstring name(kName);
   std::wstring data(kDataStr);
   work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, key_to_create,
-                                          name, data, false)));
+      WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER,
+                                          key_to_create,
+                                          WorkItem::kWow64Default,
+                                          name,
+                                          data,
+                                          false)));
   conditional_work_item_list->AddWorkItem(work_item.release());
 
   work_item_list->AddWorkItem(conditional_work_item_list.release());
 
   EXPECT_TRUE(work_item_list->Do());
 
   // Verify all WorkItems have been executed.
   RegKey key;
   EXPECT_EQ(ERROR_SUCCESS,
       key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ));
@@ skipping 27 matching lines @@
       WorkItem::CreateCreateDirWorkItem(dir_to_create)));
   work_item_list->AddWorkItem(work_item.release());
 
   scoped_ptr<WorkItemList> conditional_work_item_list(
       WorkItem::CreateConditionalWorkItemList(
           new ConditionRunIfFileExists(dir_to_create.AppendASCII("c"))));
 
   std::wstring key_to_create(kTestRoot);
   key_to_create.push_back(base::FilePath::kSeparators[0]);
   key_to_create.append(L"ExecutionSuccess");
-  work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, key_to_create)));
+  work_item.reset(
+      reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem(
+          HKEY_CURRENT_USER, key_to_create, WorkItem::kWow64Default)));
   conditional_work_item_list->AddWorkItem(work_item.release());
 
   std::wstring name(kName);
   std::wstring data(kDataStr);
   work_item.reset(reinterpret_cast<WorkItem*>(
-      WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, key_to_create,
-                                          name, data, false)));
+      WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER,
+                                          key_to_create,
+                                          WorkItem::kWow64Default,
+                                          name,
+                                          data,
+                                          false)));
   conditional_work_item_list->AddWorkItem(work_item.release());
 
   work_item_list->AddWorkItem(conditional_work_item_list.release());
 
   EXPECT_TRUE(work_item_list->Do());
 
   // Verify that the WorkItems added as part of the conditional list have NOT
   // been executed.
   RegKey key;
   EXPECT_NE(ERROR_SUCCESS,
       key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ));
   std::wstring read_out;
   EXPECT_NE(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out));
   key.Close();
 
   // Verify that the other work item was executed.
   EXPECT_TRUE(base::PathExists(dir_to_create));
 
   work_item_list->Rollback();
 
   // Verify everything is rolled back.
   // The value must have been deleted first in roll back otherwise the key
   // can not be deleted.
   EXPECT_NE(ERROR_SUCCESS,
       key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ));
   EXPECT_FALSE(base::PathExists(top_dir_to_create));
 }